linux-user/uname.c

   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 <stdio.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_X86_64)
  56     return "x86-64";
  57 #elif defined(TARGET_I386)
  58     /* see arch/x86/kernel/cpu/bugs.c: check_bugs(), 386, 486, 586, 686 */
  59     CPUState *cpu = ENV_GET_CPU((CPUX86State *)cpu_env);
  60     int family = object_property_get_int(OBJECT(cpu), "family", NULL);
  61     if (family == 4) {
  62         return "i486";
  63     }
  64     if (family == 5) {
  65         return "i586";
  66     }
  67     return "i686";
  68 #else
  69     /* default is #define-d in each arch/ subdir */
  70     return UNAME_MACHINE;
  71 #endif
  72 }
  73
  74
  75 #define COPY_UTSNAME_FIELD(dest, src) \
  76   do { \
  77       /* __NEW_UTS_LEN doesn't include terminating null */ \
  78       (void) strncpy((dest), (src), __NEW_UTS_LEN); \
  79       (dest)[__NEW_UTS_LEN] = '\0'; \
  80   } while (0)
  81
  82 int sys_uname(struct new_utsname *buf)
  83 {
  84   struct utsname uts_buf;
  85
  86   if (uname(&uts_buf) < 0)
  87       return (-1);
  88
  89   /*
  90    * Just in case these have some differences, we
  91    * translate utsname to new_utsname (which is the
  92    * struct linux kernel uses).
  93    */
  94
  95   memset(buf, 0, sizeof(*buf));
  96   COPY_UTSNAME_FIELD(buf->sysname, uts_buf.sysname);
  97   COPY_UTSNAME_FIELD(buf->nodename, uts_buf.nodename);
  98   COPY_UTSNAME_FIELD(buf->release, uts_buf.release);
  99   COPY_UTSNAME_FIELD(buf->version, uts_buf.version);
 100   COPY_UTSNAME_FIELD(buf->machine, uts_buf.machine);
 101 #ifdef _GNU_SOURCE
 102   COPY_UTSNAME_FIELD(buf->domainname, uts_buf.domainname);
 103 #endif
 104   return (0);
 105
 106 #undef COPY_UTSNAME_FIELD
 107 }
 108
 109 static int relstr_to_int(const char *s)
 110 {
 111     /* Convert a uname release string like "2.6.18" to an integer
 112      * of the form 0x020612. (Beware that 0x020612 is *not* 2.6.12.)
 113      */
 114     int i, n, tmp;
 115
 116     tmp = 0;
 117     for (i = 0; i < 3; i++) {
 118         n = 0;
 119         while (*s >= '0' && *s <= '9') {
 120             n *= 10;
 121             n += *s - '0';
 122             s++;
 123         }
 124         tmp = (tmp << 8) + n;
 125         if (*s == '.') {
 126             s++;
 127         }
 128     }
 129     return tmp;
 130 }
 131
 132 int get_osversion(void)
 133 {
 134     static int osversion;
 135     struct new_utsname buf;
 136     const char *s;
 137
 138     if (osversion)
 139         return osversion;
 140     if (qemu_uname_release && *qemu_uname_release) {
 141         s = qemu_uname_release;
 142     } else {
 143         if (sys_uname(&buf))
 144             return 0;
 145         s = buf.release;
 146     }
 147     osversion = relstr_to_int(s);
 148     return osversion;
 149 }
 150
 151 void init_qemu_uname_release(void)
 152 {
 153     /* Initialize qemu_uname_release for later use.
 154      * If the host kernel is too old and the user hasn't asked for
 155      * a specific fake version number, we might want to fake a minimum
 156      * target kernel version.
 157      */
 158     struct new_utsname buf;
 159
 160     if (qemu_uname_release && *qemu_uname_release) {
 161         return;
 162     }
 163
 164     if (sys_uname(&buf)) {
 165         return;
 166     }
 167
 168     if (relstr_to_int(buf.release) < relstr_to_int(UNAME_MINIMUM_RELEASE)) {
 169         qemu_uname_release = UNAME_MINIMUM_RELEASE;
 170     }
 171 }