qemu

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 "user-internals.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(CPUArchState *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
#if TARGET_BIG_ENDIAN
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(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