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_GET_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 /* __NEW_UTS_LEN doesn't include terminating null */ \ 76 (void) strncpy((dest), (src), __NEW_UTS_LEN); \ 77 (dest)[__NEW_UTS_LEN] = '\0'; \ 78 } while (0) 79 80 int sys_uname(struct new_utsname *buf) 81 { 82 struct utsname uts_buf; 83 84 if (uname(&uts_buf) < 0) 85 return (-1); 86 87 /* 88 * Just in case these have some differences, we 89 * translate utsname to new_utsname (which is the 90 * struct linux kernel uses). 91 */ 92 93 memset(buf, 0, sizeof(*buf)); 94 COPY_UTSNAME_FIELD(buf->sysname, uts_buf.sysname); 95 COPY_UTSNAME_FIELD(buf->nodename, uts_buf.nodename); 96 COPY_UTSNAME_FIELD(buf->release, uts_buf.release); 97 COPY_UTSNAME_FIELD(buf->version, uts_buf.version); 98 COPY_UTSNAME_FIELD(buf->machine, uts_buf.machine); 99 #ifdef _GNU_SOURCE 100 COPY_UTSNAME_FIELD(buf->domainname, uts_buf.domainname); 101 #endif 102 return (0); 103 104 #undef COPY_UTSNAME_FIELD 105 } 106 107 static int relstr_to_int(const char *s) 108 { 109 /* Convert a uname release string like "2.6.18" to an integer 110 * of the form 0x020612. (Beware that 0x020612 is *not* 2.6.12.) 111 */ 112 int i, n, tmp; 113 114 tmp = 0; 115 for (i = 0; i < 3; i++) { 116 n = 0; 117 while (*s >= '0' && *s <= '9') { 118 n *= 10; 119 n += *s - '0'; 120 s++; 121 } 122 tmp = (tmp << 8) + n; 123 if (*s == '.') { 124 s++; 125 } 126 } 127 return tmp; 128 } 129 130 int get_osversion(void) 131 { 132 static int osversion; 133 struct new_utsname buf; 134 const char *s; 135 136 if (osversion) 137 return osversion; 138 if (qemu_uname_release && *qemu_uname_release) { 139 s = qemu_uname_release; 140 } else { 141 if (sys_uname(&buf)) 142 return 0; 143 s = buf.release; 144 } 145 osversion = relstr_to_int(s); 146 return osversion; 147 } 148 149 void init_qemu_uname_release(void) 150 { 151 /* Initialize qemu_uname_release for later use. 152 * If the host kernel is too old and the user hasn't asked for 153 * a specific fake version number, we might want to fake a minimum 154 * target kernel version. 155 */ 156 struct new_utsname buf; 157 158 if (qemu_uname_release && *qemu_uname_release) { 159 return; 160 } 161 162 if (sys_uname(&buf)) { 163 return; 164 } 165 166 if (relstr_to_int(buf.release) < relstr_to_int(UNAME_MINIMUM_RELEASE)) { 167 qemu_uname_release = UNAME_MINIMUM_RELEASE; 168 } 169 } 170