1 | /* |
2 | * cpu to uname machine name map |
3 | * |
4 | * Copyright (c) 2009 Loïc Minier |
5 | * |
6 | * This program is free software; you can redistribute it and/or modify |
7 | * it under the terms of the GNU General Public License as published by |
8 | * the Free Software Foundation; either version 2 of the License, or |
9 | * (at your option) any later version. |
10 | * |
11 | * This program is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | * GNU General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU General Public License |
17 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
18 | */ |
19 | |
20 | #include "qemu/osdep.h" |
21 | |
22 | #include "qemu.h" |
23 | //#include "qemu-common.h" |
24 | #include "uname.h" |
25 | |
26 | /* return highest utsname machine name for emulated instruction set |
27 | * |
28 | * NB: the default emulated CPU ("any") might not match any existing CPU, e.g. |
29 | * on ARM it has all features turned on, so there is no perfect arch string to |
30 | * return here */ |
31 | const char *cpu_to_uname_machine(void *cpu_env) |
32 | { |
33 | #if defined(TARGET_ARM) && !defined(TARGET_AARCH64) |
34 | |
35 | /* utsname machine name on linux arm is CPU arch name + endianness, e.g. |
36 | * armv7l; to get a list of CPU arch names from the linux source, use: |
37 | * grep arch_name: -A1 linux/arch/arm/mm/proc-*.S |
38 | * see arch/arm/kernel/setup.c: setup_processor() |
39 | */ |
40 | |
41 | /* in theory, endianness is configurable on some ARM CPUs, but this isn't |
42 | * used in user mode emulation */ |
43 | #ifdef TARGET_WORDS_BIGENDIAN |
44 | #define utsname_suffix "b" |
45 | #else |
46 | #define utsname_suffix "l" |
47 | #endif |
48 | if (arm_feature(cpu_env, ARM_FEATURE_V7)) |
49 | return "armv7" utsname_suffix; |
50 | if (arm_feature(cpu_env, ARM_FEATURE_V6)) |
51 | return "armv6" utsname_suffix; |
52 | /* earliest emulated CPU is ARMv5TE; qemu can emulate the 1026, but not its |
53 | * Jazelle support */ |
54 | return "armv5te" utsname_suffix; |
55 | #elif defined(TARGET_I386) && !defined(TARGET_X86_64) |
56 | /* see arch/x86/kernel/cpu/bugs.c: check_bugs(), 386, 486, 586, 686 */ |
57 | CPUState *cpu = env_cpu((CPUX86State *)cpu_env); |
58 | int family = object_property_get_int(OBJECT(cpu), "family" , NULL); |
59 | if (family == 4) { |
60 | return "i486" ; |
61 | } |
62 | if (family == 5) { |
63 | return "i586" ; |
64 | } |
65 | return "i686" ; |
66 | #else |
67 | /* default is #define-d in each arch/ subdir */ |
68 | return UNAME_MACHINE; |
69 | #endif |
70 | } |
71 | |
72 | |
73 | #define COPY_UTSNAME_FIELD(dest, src) \ |
74 | do { \ |
75 | memcpy((dest), (src), MIN(sizeof(src), sizeof(dest))); \ |
76 | (dest)[sizeof(dest) - 1] = '\0'; \ |
77 | } while (0) |
78 | |
79 | int sys_uname(struct new_utsname *buf) |
80 | { |
81 | struct utsname uts_buf; |
82 | |
83 | if (uname(&uts_buf) < 0) |
84 | return (-1); |
85 | |
86 | /* |
87 | * Just in case these have some differences, we |
88 | * translate utsname to new_utsname (which is the |
89 | * struct linux kernel uses). |
90 | */ |
91 | |
92 | memset(buf, 0, sizeof(*buf)); |
93 | COPY_UTSNAME_FIELD(buf->sysname, uts_buf.sysname); |
94 | COPY_UTSNAME_FIELD(buf->nodename, uts_buf.nodename); |
95 | COPY_UTSNAME_FIELD(buf->release, uts_buf.release); |
96 | COPY_UTSNAME_FIELD(buf->version, uts_buf.version); |
97 | COPY_UTSNAME_FIELD(buf->machine, uts_buf.machine); |
98 | #ifdef _GNU_SOURCE |
99 | COPY_UTSNAME_FIELD(buf->domainname, uts_buf.domainname); |
100 | #endif |
101 | return (0); |
102 | |
103 | #undef COPY_UTSNAME_FIELD |
104 | } |
105 | |
106 | static int relstr_to_int(const char *s) |
107 | { |
108 | /* Convert a uname release string like "2.6.18" to an integer |
109 | * of the form 0x020612. (Beware that 0x020612 is *not* 2.6.12.) |
110 | */ |
111 | int i, n, tmp; |
112 | |
113 | tmp = 0; |
114 | for (i = 0; i < 3; i++) { |
115 | n = 0; |
116 | while (*s >= '0' && *s <= '9') { |
117 | n *= 10; |
118 | n += *s - '0'; |
119 | s++; |
120 | } |
121 | tmp = (tmp << 8) + n; |
122 | if (*s == '.') { |
123 | s++; |
124 | } |
125 | } |
126 | return tmp; |
127 | } |
128 | |
129 | int get_osversion(void) |
130 | { |
131 | static int osversion; |
132 | struct new_utsname buf; |
133 | const char *s; |
134 | |
135 | if (osversion) |
136 | return osversion; |
137 | if (qemu_uname_release && *qemu_uname_release) { |
138 | s = qemu_uname_release; |
139 | } else { |
140 | if (sys_uname(&buf)) |
141 | return 0; |
142 | s = buf.release; |
143 | } |
144 | osversion = relstr_to_int(s); |
145 | return osversion; |
146 | } |
147 | |
148 | void init_qemu_uname_release(void) |
149 | { |
150 | /* Initialize qemu_uname_release for later use. |
151 | * If the host kernel is too old and the user hasn't asked for |
152 | * a specific fake version number, we might want to fake a minimum |
153 | * target kernel version. |
154 | */ |
155 | struct new_utsname buf; |
156 | |
157 | if (qemu_uname_release && *qemu_uname_release) { |
158 | return; |
159 | } |
160 | |
161 | if (sys_uname(&buf)) { |
162 | return; |
163 | } |
164 | |
165 | if (relstr_to_int(buf.release) < relstr_to_int(UNAME_MINIMUM_RELEASE)) { |
166 | qemu_uname_release = UNAME_MINIMUM_RELEASE; |
167 | } |
168 | } |
169 | |