LXR qemu/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 "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 */
  31const 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
  80int 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
 107static 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
 130int 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
 149void 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