]> Git Repo - qemu.git/blame - target-i386/helper.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
KVM: Rework of guest debug state writing
[qemu.git] / target-i386 / helper.c
CommitLineData
2c0262af 1/*
eaa728ee 2 * i386 helpers (without register variable usage)
5fafdf24 3 *
2c0262af
FB		 4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library 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 GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
8167ee88 17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
2c0262af 18 */
eaa728ee
FB		 19#include <stdarg.h>
20#include <stdlib.h>
21#include <stdio.h>
22#include <string.h>
23#include <inttypes.h>
24#include <signal.h>
2c0262af 25
eaa728ee
FB		 26#include "cpu.h"
27#include "exec-all.h"
eaa728ee 28#include "qemu-common.h"
7ba1e619 29#include "kvm.h"
f3f2d9be 30
eaa728ee 31//#define DEBUG_MMU
b5ec5ce0 32#include "qemu-option.h"
33#include "qemu-config.h"
2c0262af 34
c6fa82c4 35/* feature flags taken from "Intel Processor Identification and the CPUID
b5ec5ce0 36 * Instruction" and AMD's "CPUID Specification". In cases of disagreement
37 * between feature naming conventions, aliases may be added.
38 */
c6fa82c4 39static const char *feature_name[] = {
b5ec5ce0 40 "fpu", "vme", "de", "pse",
41 "tsc", "msr", "pae", "mce",
42 "cx8", "apic", NULL, "sep",
43 "mtrr", "pge", "mca", "cmov",
44 "pat", "pse36", "pn" /* Intel psn */, "clflush" /* Intel clfsh */,
45 NULL, "ds" /* Intel dts */, "acpi", "mmx",
46 "fxsr", "sse", "sse2", "ss",
47 "ht" /* Intel htt */, "tm", "ia64", "pbe",
c6fa82c4
AK		 48};
49static const char *ext_feature_name[] = {
b5ec5ce0 50 "pni|sse3" /* Intel,AMD sse3 */, NULL, NULL, "monitor",
51 "ds_cpl", "vmx", NULL /* Linux smx */, "est",
52 "tm2", "ssse3", "cid", NULL,
53 NULL, "cx16", "xtpr", NULL,
54 NULL, NULL, "dca", "sse4.1|sse4_1",
55 "sse4.2|sse4_2", "x2apic", NULL, "popcnt",
56 NULL, NULL, NULL, NULL,
57 NULL, NULL, NULL, "hypervisor",
c6fa82c4
AK		 58};
59static const char *ext2_feature_name[] = {
b5ec5ce0 60 "fpu", "vme", "de", "pse",
61 "tsc", "msr", "pae", "mce",
62 "cx8" /* AMD CMPXCHG8B */, "apic", NULL, "syscall",
63 "mtrr", "pge", "mca", "cmov",
64 "pat", "pse36", NULL, NULL /* Linux mp */,
65 "nx" /* Intel xd */, NULL, "mmxext", "mmx",
66 "fxsr", "fxsr_opt" /* AMD ffxsr */, "pdpe1gb" /* AMD Page1GB */, "rdtscp",
67 NULL, "lm" /* Intel 64 */, "3dnowext", "3dnow",
c6fa82c4
AK		 68};
69static const char *ext3_feature_name[] = {
b5ec5ce0 70 "lahf_lm" /* AMD LahfSahf */, "cmp_legacy", "svm", "extapic" /* AMD ExtApicSpace */,
71 "cr8legacy" /* AMD AltMovCr8 */, "abm", "sse4a", "misalignsse",
72 "3dnowprefetch", "osvw", NULL /* Linux ibs */, NULL,
73 "skinit", "wdt", NULL, NULL,
74 NULL, NULL, NULL, NULL,
75 NULL, NULL, NULL, NULL,
76 NULL, NULL, NULL, NULL,
77 NULL, NULL, NULL, NULL,
c6fa82c4
AK		 78};
79
bb0300dc
GN		 80static const char *kvm_feature_name[] = {
81 "kvmclock", "kvm_nopiodelay", "kvm_mmu", NULL, NULL, NULL, NULL, NULL,
82 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
83 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
84 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
85};
86
b5ec5ce0 87/* collects per-function cpuid data
88 */
89typedef struct model_features_t {
90 uint32_t *guest_feat;
91 uint32_t *host_feat;
92 uint32_t check_feat;
93 const char **flag_names;
94 uint32_t cpuid;
95 } model_features_t;
96
97int check_cpuid = 0;
98int enforce_cpuid = 0;
99
100static void host_cpuid(uint32_t function, uint32_t count, uint32_t *eax,
101 uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
102
103#define iswhite(c) ((c) && ((c) <= ' ' || '~' < (c)))
104
105/* general substring compare of *[s1..e1) and *[s2..e2). sx is start of
106 * a substring. ex if !NULL points to the first char after a substring,
107 * otherwise the string is assumed to sized by a terminating nul.
108 * Return lexical ordering of *s1:*s2.
109 */
110static int sstrcmp(const char *s1, const char *e1, const char *s2,
111 const char *e2)
112{
113 for (;;) {
114 if (!*s1 || !*s2 || *s1 != *s2)
115 return (*s1 - *s2);
116 ++s1, ++s2;
117 if (s1 == e1 && s2 == e2)
118 return (0);
119 else if (s1 == e1)
120 return (*s2);
121 else if (s2 == e2)
122 return (*s1);
123 }
124}
125
126/* compare *[s..e) to *altstr. *altstr may be a simple string or multiple
127 * '|' delimited (possibly empty) strings in which case search for a match
128 * within the alternatives proceeds left to right. Return 0 for success,
129 * non-zero otherwise.
130 */
131static int altcmp(const char *s, const char *e, const char *altstr)
132{
133 const char *p, *q;
134
135 for (q = p = altstr; ; ) {
136 while (*p && *p != '|')
137 ++p;
138 if ((q == p && !*s) || (q != p && !sstrcmp(s, e, q, p)))
139 return (0);
140 if (!*p)
141 return (1);
142 else
143 q = ++p;
144 }
145}
146
147/* search featureset for flag *[s..e), if found set corresponding bit in
148 * *pval and return success, otherwise return zero
149 */
150static int lookup_feature(uint32_t *pval, const char *s, const char *e,
151 const char **featureset)
152{
153 uint32_t mask;
154 const char **ppc;
155
156 for (mask = 1, ppc = featureset; mask; mask <<= 1, ++ppc)
157 if (*ppc && !altcmp(s, e, *ppc)) {
158 *pval |= mask;
159 break;
160 }
161 return (mask ? 1 : 0);
162}
163
6d2edc43
AP		 164static void add_flagname_to_bitmaps(const char *flagname, uint32_t *features,
165 uint32_t *ext_features,
166 uint32_t *ext2_features,
bb0300dc
GN		 167 uint32_t *ext3_features,
168 uint32_t *kvm_features)
eaa728ee 169{
b5ec5ce0 170 if (!lookup_feature(features, flagname, NULL, feature_name) &&
171 !lookup_feature(ext_features, flagname, NULL, ext_feature_name) &&
172 !lookup_feature(ext2_features, flagname, NULL, ext2_feature_name) &&
173 !lookup_feature(ext3_features, flagname, NULL, ext3_feature_name) &&
174 !lookup_feature(kvm_features, flagname, NULL, kvm_feature_name))
175 fprintf(stderr, "CPU feature %s not found\n", flagname);
eaa728ee 176}
2c0262af 177
c227f099 178typedef struct x86_def_t {
b5ec5ce0 179 struct x86_def_t *next;
eaa728ee
FB		 180 const char *name;
181 uint32_t level;
182 uint32_t vendor1, vendor2, vendor3;
183 int family;
184 int model;
185 int stepping;
bb0300dc 186 uint32_t features, ext_features, ext2_features, ext3_features, kvm_features;
eaa728ee 187 uint32_t xlevel;
40f8e2fa 188 char model_id[48];
ef768138 189 int vendor_override;
b5ec5ce0 190 uint32_t flags;
c227f099 191} x86_def_t;
eaa728ee
FB		 192
193#define I486_FEATURES (CPUID_FP87 | CPUID_VME | CPUID_PSE)
194#define PENTIUM_FEATURES (I486_FEATURES | CPUID_DE | CPUID_TSC | \
c84bd4f1 195 CPUID_MSR | CPUID_MCE | CPUID_CX8 | CPUID_MMX | CPUID_APIC)
eaa728ee
FB		 196#define PENTIUM2_FEATURES (PENTIUM_FEATURES | CPUID_PAE | CPUID_SEP | \
197 CPUID_MTRR | CPUID_PGE | CPUID_MCA | CPUID_CMOV | CPUID_PAT | \
198 CPUID_PSE36 | CPUID_FXSR)
199#define PENTIUM3_FEATURES (PENTIUM2_FEATURES | CPUID_SSE)
200#define PPRO_FEATURES (CPUID_FP87 | CPUID_DE | CPUID_PSE | CPUID_TSC | \
201 CPUID_MSR | CPUID_MCE | CPUID_CX8 | CPUID_PGE | CPUID_CMOV | \
202 CPUID_PAT | CPUID_FXSR | CPUID_MMX | CPUID_SSE | CPUID_SSE2 | \
203 CPUID_PAE | CPUID_SEP | CPUID_APIC)
b5ec5ce0 204
205/* maintains list of cpu model definitions
206 */
207static x86_def_t *x86_defs = {NULL};
208
209/* built-in cpu model definitions (deprecated)
210 */
211static x86_def_t builtin_x86_defs[] = {
eaa728ee
FB		 212#ifdef TARGET_X86_64
213 {
214 .name = "qemu64",
ac72472b 215 .level = 4,
c5096daf
AZ		 216 .vendor1 = CPUID_VENDOR_AMD_1,
217 .vendor2 = CPUID_VENDOR_AMD_2,
218 .vendor3 = CPUID_VENDOR_AMD_3,
eaa728ee
FB		 219 .family = 6,
220 .model = 2,
221 .stepping = 3,
222 .features = PPRO_FEATURES |
223 /* these features are needed for Win64 and aren't fully implemented */
224 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
225 /* this feature is needed for Solaris and isn't fully implemented */
226 CPUID_PSE36,
f1e00a9c 227 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_CX16 | CPUID_EXT_POPCNT,
eaa728ee 228 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) |
09ac35ac 229 CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
f1e00a9c
AP		 230 .ext3_features = CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM |
231 CPUID_EXT3_ABM | CPUID_EXT3_SSE4A,
eaa728ee 232 .xlevel = 0x8000000A,
40f8e2fa 233 .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
eaa728ee 234 },
9bdba1b6
AL		 235 {
236 .name = "phenom",
237 .level = 5,
238 .vendor1 = CPUID_VENDOR_AMD_1,
239 .vendor2 = CPUID_VENDOR_AMD_2,
240 .vendor3 = CPUID_VENDOR_AMD_3,
241 .family = 16,
242 .model = 2,
243 .stepping = 3,
244 /* Missing: CPUID_VME, CPUID_HT */
245 .features = PPRO_FEATURES |
246 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
247 CPUID_PSE36,
f1e00a9c
AP		 248 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_CX16 |
249 CPUID_EXT_POPCNT,
9bdba1b6
AL		 250 /* Missing: CPUID_EXT2_PDPE1GB, CPUID_EXT2_RDTSCP */
251 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) |
252 CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX |
253 CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT | CPUID_EXT2_MMXEXT |
254 CPUID_EXT2_FFXSR,
f1e00a9c
AP		 255 /* Missing: CPUID_EXT3_CMP_LEG, CPUID_EXT3_EXTAPIC,
256 CPUID_EXT3_CR8LEG,
9bdba1b6
AL		 257 CPUID_EXT3_MISALIGNSSE, CPUID_EXT3_3DNOWPREFETCH,
258 CPUID_EXT3_OSVW, CPUID_EXT3_IBS */
f1e00a9c
AP		 259 .ext3_features = CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM |
260 CPUID_EXT3_ABM | CPUID_EXT3_SSE4A,
9bdba1b6
AL		 261 .xlevel = 0x8000001A,
262 .model_id = "AMD Phenom(tm) 9550 Quad-Core Processor"
263 },
e737b32a
AZ		 264 {
265 .name = "core2duo",
558fa836 266 .level = 10,
e737b32a
AZ		 267 .family = 6,
268 .model = 15,
269 .stepping = 11,
558fa836
PB		 270 /* The original CPU also implements these features:
271 CPUID_VME, CPUID_DTS, CPUID_ACPI, CPUID_SS, CPUID_HT,
272 CPUID_TM, CPUID_PBE */
0086de1c 273 .features = PPRO_FEATURES |
e737b32a
AZ		 274 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
275 CPUID_PSE36,
558fa836
PB		 276 /* The original CPU also implements these ext features:
277 CPUID_EXT_DTES64, CPUID_EXT_DSCPL, CPUID_EXT_VMX, CPUID_EXT_EST,
278 CPUID_EXT_TM2, CPUID_EXT_CX16, CPUID_EXT_XTPR, CPUID_EXT_PDCM */
0086de1c 279 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_SSSE3,
558fa836 280 .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
f1e00a9c 281 .ext3_features = CPUID_EXT3_LAHF_LM,
45fd08ef 282 .xlevel = 0x80000008,
e737b32a
AZ		 283 .model_id = "Intel(R) Core(TM)2 Duo CPU T7700 @ 2.40GHz",
284 },
d1cd4bf4
AP		 285 {
286 .name = "kvm64",
287 .level = 5,
288 .vendor1 = CPUID_VENDOR_INTEL_1,
289 .vendor2 = CPUID_VENDOR_INTEL_2,
290 .vendor3 = CPUID_VENDOR_INTEL_3,
291 .family = 15,
292 .model = 6,
293 .stepping = 1,
294 /* Missing: CPUID_VME, CPUID_HT */
295 .features = PPRO_FEATURES |
296 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
297 CPUID_PSE36,
298 /* Missing: CPUID_EXT_POPCNT, CPUID_EXT_MONITOR */
299 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_CX16,
300 /* Missing: CPUID_EXT2_PDPE1GB, CPUID_EXT2_RDTSCP */
301 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) |
302 CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
303 /* Missing: CPUID_EXT3_LAHF_LM, CPUID_EXT3_CMP_LEG, CPUID_EXT3_EXTAPIC,
304 CPUID_EXT3_CR8LEG, CPUID_EXT3_ABM, CPUID_EXT3_SSE4A,
305 CPUID_EXT3_MISALIGNSSE, CPUID_EXT3_3DNOWPREFETCH,
306 CPUID_EXT3_OSVW, CPUID_EXT3_IBS, CPUID_EXT3_SVM */
307 .ext3_features = 0,
308 .xlevel = 0x80000008,
309 .model_id = "Common KVM processor"
310 },
eaa728ee
FB		 311#endif
312 {
313 .name = "qemu32",
ac72472b 314 .level = 4,
eaa728ee
FB		 315 .family = 6,
316 .model = 3,
317 .stepping = 3,
318 .features = PPRO_FEATURES,
f1e00a9c 319 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_POPCNT,
eaa728ee 320 .xlevel = 0,
40f8e2fa 321 .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
eaa728ee 322 },
45fd08ef
AJ		 323 {
324 .name = "coreduo",
325 .level = 10,
326 .family = 6,
327 .model = 14,
328 .stepping = 8,
329 /* The original CPU also implements these features:
330 CPUID_DTS, CPUID_ACPI, CPUID_SS, CPUID_HT,
331 CPUID_TM, CPUID_PBE */
332 .features = PPRO_FEATURES | CPUID_VME |
333 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA,
334 /* The original CPU also implements these ext features:
335 CPUID_EXT_VMX, CPUID_EXT_EST, CPUID_EXT_TM2, CPUID_EXT_XTPR,
336 CPUID_EXT_PDCM */
337 .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR,
338 .ext2_features = CPUID_EXT2_NX,
339 .xlevel = 0x80000008,
340 .model_id = "Genuine Intel(R) CPU T2600 @ 2.16GHz",
341 },
eaa728ee
FB		 342 {
343 .name = "486",
344 .level = 0,
345 .family = 4,
346 .model = 0,
347 .stepping = 0,
348 .features = I486_FEATURES,
349 .xlevel = 0,
350 },
351 {
352 .name = "pentium",
353 .level = 1,
354 .family = 5,
355 .model = 4,
356 .stepping = 3,
357 .features = PENTIUM_FEATURES,
358 .xlevel = 0,
359 },
360 {
361 .name = "pentium2",
362 .level = 2,
363 .family = 6,
364 .model = 5,
365 .stepping = 2,
366 .features = PENTIUM2_FEATURES,
367 .xlevel = 0,
368 },
369 {
370 .name = "pentium3",
371 .level = 2,
372 .family = 6,
373 .model = 7,
374 .stepping = 3,
375 .features = PENTIUM3_FEATURES,
376 .xlevel = 0,
377 },
378 {
379 .name = "athlon",
380 .level = 2,
fe4bce09
AP		 381 .vendor1 = CPUID_VENDOR_AMD_1,
382 .vendor2 = CPUID_VENDOR_AMD_2,
383 .vendor3 = CPUID_VENDOR_AMD_3,
eaa728ee
FB		 384 .family = 6,
385 .model = 2,
386 .stepping = 3,
558fa836 387 .features = PPRO_FEATURES | CPUID_PSE36 | CPUID_VME | CPUID_MTRR | CPUID_MCA,
eaa728ee
FB		 388 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) | CPUID_EXT2_MMXEXT | CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT,
389 .xlevel = 0x80000008,
40f8e2fa
FB		 390 /* XXX: put another string ? */
391 .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
eaa728ee 392 },
0086de1c 393 {
c0d82995 394 .name = "n270",
0086de1c
AZ		 395 /* original is on level 10 */
396 .level = 5,
397 .family = 6,
398 .model = 28,
399 .stepping = 2,
400 .features = PPRO_FEATURES |
401 CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | CPUID_VME,
402 /* Missing: CPUID_DTS | CPUID_ACPI | CPUID_SS |
403 * CPUID_HT | CPUID_TM | CPUID_PBE */
404 /* Some CPUs got no CPUID_SEP */
405 .ext_features = CPUID_EXT_MONITOR |
853f6931 406 CPUID_EXT_SSE3 /* PNI */ | CPUID_EXT_SSSE3,
0086de1c
AZ		 407 /* Missing: CPUID_EXT_DSCPL | CPUID_EXT_EST |
408 * CPUID_EXT_TM2 | CPUID_EXT_XTPR */
409 .ext2_features = (PPRO_FEATURES & 0x0183F3FF) | CPUID_EXT2_NX,
410 /* Missing: .ext3_features = CPUID_EXT3_LAHF_LM */
411 .xlevel = 0x8000000A,
412 .model_id = "Intel(R) Atom(TM) CPU N270 @ 1.60GHz",
413 },
eaa728ee 414};
2c0262af 415
fe4bce09
AP		 416static int cpu_x86_fill_model_id(char *str)
417{
e6f9e6b4 418 uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
fe4bce09
AP		 419 int i;
420
421 for (i = 0; i < 3; i++) {
422 host_cpuid(0x80000002 + i, 0, &eax, &ebx, &ecx, &edx);
423 memcpy(str + i * 16 + 0, &eax, 4);
424 memcpy(str + i * 16 + 4, &ebx, 4);
425 memcpy(str + i * 16 + 8, &ecx, 4);
426 memcpy(str + i * 16 + 12, &edx, 4);
427 }
428 return 0;
429}
430
c227f099 431static int cpu_x86_fill_host(x86_def_t *x86_cpu_def)
fe4bce09 432{
97b35e35 433 uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
fe4bce09
AP		 434
435 x86_cpu_def->name = "host";
436 host_cpuid(0x0, 0, &eax, &ebx, &ecx, &edx);
437 x86_cpu_def->level = eax;
438 x86_cpu_def->vendor1 = ebx;
439 x86_cpu_def->vendor2 = edx;
440 x86_cpu_def->vendor3 = ecx;
441
442 host_cpuid(0x1, 0, &eax, &ebx, &ecx, &edx);
443 x86_cpu_def->family = ((eax >> 8) & 0x0F) + ((eax >> 20) & 0xFF);
444 x86_cpu_def->model = ((eax >> 4) & 0x0F) | ((eax & 0xF0000) >> 12);
445 x86_cpu_def->stepping = eax & 0x0F;
446 x86_cpu_def->ext_features = ecx;
447 x86_cpu_def->features = edx;
448
449 host_cpuid(0x80000000, 0, &eax, &ebx, &ecx, &edx);
450 x86_cpu_def->xlevel = eax;
451
452 host_cpuid(0x80000001, 0, &eax, &ebx, &ecx, &edx);
453 x86_cpu_def->ext2_features = edx;
454 x86_cpu_def->ext3_features = ecx;
455 cpu_x86_fill_model_id(x86_cpu_def->model_id);
456 x86_cpu_def->vendor_override = 0;
457
458 return 0;
459}
460
b5ec5ce0 461static int unavailable_host_feature(struct model_features_t *f, uint32_t mask)
462{
463 int i;
464
465 for (i = 0; i < 32; ++i)
466 if (1 << i & mask) {
467 fprintf(stderr, "warning: host cpuid %04x_%04x lacks requested"
468 " flag '%s' [0x%08x]\n",
469 f->cpuid >> 16, f->cpuid & 0xffff,
470 f->flag_names[i] ? f->flag_names[i] : "[reserved]", mask);
471 break;
472 }
473 return 0;
474}
475
476/* best effort attempt to inform user requested cpu flags aren't making
477 * their way to the guest. Note: ft[].check_feat ideally should be
478 * specified via a guest_def field to suppress report of extraneous flags.
479 */
480static int check_features_against_host(x86_def_t *guest_def)
481{
482 x86_def_t host_def;
483 uint32_t mask;
484 int rv, i;
485 struct model_features_t ft[] = {
486 {&guest_def->features, &host_def.features,
487 ~0, feature_name, 0x00000000},
488 {&guest_def->ext_features, &host_def.ext_features,
489 ~CPUID_EXT_HYPERVISOR, ext_feature_name, 0x00000001},
490 {&guest_def->ext2_features, &host_def.ext2_features,
491 ~PPRO_FEATURES, ext2_feature_name, 0x80000000},
492 {&guest_def->ext3_features, &host_def.ext3_features,
493 ~CPUID_EXT3_SVM, ext3_feature_name, 0x80000001}};
494
495 cpu_x86_fill_host(&host_def);
496 for (rv = 0, i = 0; i < sizeof (ft) / sizeof (ft[0]); ++i)
497 for (mask = 1; mask; mask <<= 1)
498 if (ft[i].check_feat & mask && *ft[i].guest_feat & mask &&
499 !(*ft[i].host_feat & mask)) {
500 unavailable_host_feature(&ft[i], mask);
501 rv = 1;
502 }
503 return rv;
504}
505
c227f099 506static int cpu_x86_find_by_name(x86_def_t *x86_cpu_def, const char *cpu_model)
2c0262af 507{
eaa728ee 508 unsigned int i;
c227f099 509 x86_def_t *def;
2c0262af 510
eaa728ee
FB		 511 char *s = strdup(cpu_model);
512 char *featurestr, *name = strtok(s, ",");
bb0300dc
GN		 513 uint32_t plus_features = 0, plus_ext_features = 0, plus_ext2_features = 0, plus_ext3_features = 0, plus_kvm_features = 0;
514 uint32_t minus_features = 0, minus_ext_features = 0, minus_ext2_features = 0, minus_ext3_features = 0, minus_kvm_features = 0;
a8a358bf 515 uint32_t numvalue;
2c0262af 516
b5ec5ce0 517 for (def = x86_defs; def; def = def->next)
518 if (!strcmp(name, def->name))
eaa728ee 519 break;
5e650002 520 if (kvm_enabled() && strcmp(name, "host") == 0) {
fe4bce09 521 cpu_x86_fill_host(x86_cpu_def);
5e650002
AL		 522 } else if (!def) {
523 goto error;
fe4bce09
AP		 524 } else {
525 memcpy(x86_cpu_def, def, sizeof(*def));
526 }
eaa728ee 527
bb0300dc
GN		 528 plus_kvm_features = ~0; /* not supported bits will be filtered out later */
529
6d2edc43 530 add_flagname_to_bitmaps("hypervisor", &plus_features,
bb0300dc
GN		 531 &plus_ext_features, &plus_ext2_features, &plus_ext3_features,
532 &plus_kvm_features);
6d2edc43 533
eaa728ee
FB		 534 featurestr = strtok(NULL, ",");
535
536 while (featurestr) {
537 char *val;
538 if (featurestr[0] == '+') {
bb0300dc 539 add_flagname_to_bitmaps(featurestr + 1, &plus_features, &plus_ext_features, &plus_ext2_features, &plus_ext3_features, &plus_kvm_features);
eaa728ee 540 } else if (featurestr[0] == '-') {
bb0300dc 541 add_flagname_to_bitmaps(featurestr + 1, &minus_features, &minus_ext_features, &minus_ext2_features, &minus_ext3_features, &minus_kvm_features);
eaa728ee
FB		 542 } else if ((val = strchr(featurestr, '='))) {
543 *val = 0; val++;
544 if (!strcmp(featurestr, "family")) {
545 char *err;
a8a358bf
AP		 546 numvalue = strtoul(val, &err, 0);
547 if (!*val || *err) {
eaa728ee 548 fprintf(stderr, "bad numerical value %s\n", val);
eaa728ee
FB		 549 goto error;
550 }
a8a358bf 551 x86_cpu_def->family = numvalue;
eaa728ee
FB		 552 } else if (!strcmp(featurestr, "model")) {
553 char *err;
a8a358bf
AP		 554 numvalue = strtoul(val, &err, 0);
555 if (!*val || *err || numvalue > 0xff) {
eaa728ee 556 fprintf(stderr, "bad numerical value %s\n", val);
eaa728ee
FB		 557 goto error;
558 }
a8a358bf 559 x86_cpu_def->model = numvalue;
eaa728ee
FB		 560 } else if (!strcmp(featurestr, "stepping")) {
561 char *err;
a8a358bf
AP		 562 numvalue = strtoul(val, &err, 0);
563 if (!*val || *err || numvalue > 0xf) {
eaa728ee 564 fprintf(stderr, "bad numerical value %s\n", val);
eaa728ee
FB		 565 goto error;
566 }
a8a358bf
AP		 567 x86_cpu_def->stepping = numvalue ;
568 } else if (!strcmp(featurestr, "level")) {
569 char *err;
570 numvalue = strtoul(val, &err, 0);
571 if (!*val || *err) {
572 fprintf(stderr, "bad numerical value %s\n", val);
573 goto error;
574 }
575 x86_cpu_def->level = numvalue;
576 } else if (!strcmp(featurestr, "xlevel")) {
577 char *err;
578 numvalue = strtoul(val, &err, 0);
579 if (!*val || *err) {
580 fprintf(stderr, "bad numerical value %s\n", val);
581 goto error;
582 }
583 if (numvalue < 0x80000000) {
584 numvalue += 0x80000000;
585 }
586 x86_cpu_def->xlevel = numvalue;
40f8e2fa
FB		 587 } else if (!strcmp(featurestr, "vendor")) {
588 if (strlen(val) != 12) {
589 fprintf(stderr, "vendor string must be 12 chars long\n");
590 goto error;
591 }
592 x86_cpu_def->vendor1 = 0;
593 x86_cpu_def->vendor2 = 0;
594 x86_cpu_def->vendor3 = 0;
595 for(i = 0; i < 4; i++) {
596 x86_cpu_def->vendor1 |= ((uint8_t)val[i ]) << (8 * i);
597 x86_cpu_def->vendor2 |= ((uint8_t)val[i + 4]) << (8 * i);
598 x86_cpu_def->vendor3 |= ((uint8_t)val[i + 8]) << (8 * i);
599 }
ef768138 600 x86_cpu_def->vendor_override = 1;
40f8e2fa
FB		 601 } else if (!strcmp(featurestr, "model_id")) {
602 pstrcpy(x86_cpu_def->model_id, sizeof(x86_cpu_def->model_id),
603 val);
eaa728ee
FB		 604 } else {
605 fprintf(stderr, "unrecognized feature %s\n", featurestr);
eaa728ee
FB		 606 goto error;
607 }
b5ec5ce0 608 } else if (!strcmp(featurestr, "check")) {
609 check_cpuid = 1;
610 } else if (!strcmp(featurestr, "enforce")) {
611 check_cpuid = enforce_cpuid = 1;
eaa728ee
FB		 612 } else {
613 fprintf(stderr, "feature string `%s' not in format (+feature|-feature|feature=xyz)\n", featurestr);
eaa728ee
FB		 614 goto error;
615 }
616 featurestr = strtok(NULL, ",");
617 }
618 x86_cpu_def->features |= plus_features;
619 x86_cpu_def->ext_features |= plus_ext_features;
620 x86_cpu_def->ext2_features |= plus_ext2_features;
621 x86_cpu_def->ext3_features |= plus_ext3_features;
bb0300dc 622 x86_cpu_def->kvm_features |= plus_kvm_features;
eaa728ee
FB		 623 x86_cpu_def->features &= ~minus_features;
624 x86_cpu_def->ext_features &= ~minus_ext_features;
625 x86_cpu_def->ext2_features &= ~minus_ext2_features;
626 x86_cpu_def->ext3_features &= ~minus_ext3_features;
bb0300dc 627 x86_cpu_def->kvm_features &= ~minus_kvm_features;
b5ec5ce0 628 if (check_cpuid) {
629 if (check_features_against_host(x86_cpu_def) && enforce_cpuid)
630 goto error;
631 }
eaa728ee
FB		 632 free(s);
633 return 0;
634
635error:
636 free(s);
637 return -1;
bd7a7b33
FB		 638}
639
b5ec5ce0 640/* generate a composite string into buf of all cpuid names in featureset
641 * selected by fbits. indicate truncation at bufsize in the event of overflow.
642 * if flags, suppress names undefined in featureset.
643 */
644static void listflags(char *buf, int bufsize, uint32_t fbits,
645 const char **featureset, uint32_t flags)
bd7a7b33 646{
b5ec5ce0 647 const char **p = &featureset[31];
648 char *q, *b, bit;
649 int nc;
650
651 b = 4 <= bufsize ? buf + (bufsize -= 3) - 1 : NULL;
652 *buf = '\0';
653 for (q = buf, bit = 31; fbits && bufsize; --p, fbits &= ~(1 << bit), --bit)
654 if (fbits & 1 << bit && (*p || !flags)) {
655 if (*p)
656 nc = snprintf(q, bufsize, "%s%s", q == buf ? "" : " ", *p);
657 else
658 nc = snprintf(q, bufsize, "%s[%d]", q == buf ? "" : " ", bit);
659 if (bufsize <= nc) {
d354899c
BS		 660 if (b) {
661 memcpy(b, "...", sizeof("..."));
662 }
b5ec5ce0 663 return;
664 }
665 q += nc;
666 bufsize -= nc;
667 }
668}
eaa728ee 669
b5ec5ce0 670/* generate CPU information:
671 * -? list model names
672 * -?model list model names/IDs
673 * -?dump output all model (x86_def_t) data
674 * -?cpuid list all recognized cpuid flag names
675 */
676void x86_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
677 const char *optarg)
678{
679 unsigned char model = !strcmp("?model", optarg);
680 unsigned char dump = !strcmp("?dump", optarg);
681 unsigned char cpuid = !strcmp("?cpuid", optarg);
682 x86_def_t *def;
683 char buf[256];
684
685 if (cpuid) {
686 (*cpu_fprintf)(f, "Recognized CPUID flags:\n");
687 listflags(buf, sizeof (buf), (uint32_t)~0, feature_name, 1);
688 (*cpu_fprintf)(f, " f_edx: %s\n", buf);
689 listflags(buf, sizeof (buf), (uint32_t)~0, ext_feature_name, 1);
690 (*cpu_fprintf)(f, " f_ecx: %s\n", buf);
691 listflags(buf, sizeof (buf), (uint32_t)~0, ext2_feature_name, 1);
692 (*cpu_fprintf)(f, " extf_edx: %s\n", buf);
693 listflags(buf, sizeof (buf), (uint32_t)~0, ext3_feature_name, 1);
694 (*cpu_fprintf)(f, " extf_ecx: %s\n", buf);
695 return;
696 }
697 for (def = x86_defs; def; def = def->next) {
698 snprintf(buf, sizeof (buf), def->flags ? "[%s]": "%s", def->name);
699 if (model || dump) {
700 (*cpu_fprintf)(f, "x86 %16s %-48s\n", buf, def->model_id);
701 } else {
702 (*cpu_fprintf)(f, "x86 %16s\n", buf);
703 }
704 if (dump) {
705 memcpy(buf, &def->vendor1, sizeof (def->vendor1));
706 memcpy(buf + 4, &def->vendor2, sizeof (def->vendor2));
707 memcpy(buf + 8, &def->vendor3, sizeof (def->vendor3));
708 buf[12] = '\0';
709 (*cpu_fprintf)(f,
710 " family %d model %d stepping %d level %d xlevel 0x%x"
711 " vendor \"%s\"\n",
712 def->family, def->model, def->stepping, def->level,
713 def->xlevel, buf);
714 listflags(buf, sizeof (buf), def->features, feature_name, 0);
715 (*cpu_fprintf)(f, " feature_edx %08x (%s)\n", def->features,
716 buf);
717 listflags(buf, sizeof (buf), def->ext_features, ext_feature_name,
718 0);
719 (*cpu_fprintf)(f, " feature_ecx %08x (%s)\n", def->ext_features,
720 buf);
721 listflags(buf, sizeof (buf), def->ext2_features, ext2_feature_name,
722 0);
723 (*cpu_fprintf)(f, " extfeature_edx %08x (%s)\n",
724 def->ext2_features, buf);
725 listflags(buf, sizeof (buf), def->ext3_features, ext3_feature_name,
726 0);
727 (*cpu_fprintf)(f, " extfeature_ecx %08x (%s)\n",
728 def->ext3_features, buf);
729 (*cpu_fprintf)(f, "\n");
730 }
731 }
bd7a7b33
FB		 732}
733
eaa728ee 734static int cpu_x86_register (CPUX86State *env, const char *cpu_model)
7e84c249 735{
c227f099 736 x86_def_t def1, *def = &def1;
7e84c249 737
eaa728ee 738 if (cpu_x86_find_by_name(def, cpu_model) < 0)
7e84c249 739 return -1;
eaa728ee
FB		 740 if (def->vendor1) {
741 env->cpuid_vendor1 = def->vendor1;
742 env->cpuid_vendor2 = def->vendor2;
743 env->cpuid_vendor3 = def->vendor3;
744 } else {
c5096daf
AZ		 745 env->cpuid_vendor1 = CPUID_VENDOR_INTEL_1;
746 env->cpuid_vendor2 = CPUID_VENDOR_INTEL_2;
747 env->cpuid_vendor3 = CPUID_VENDOR_INTEL_3;
eaa728ee 748 }
ef768138 749 env->cpuid_vendor_override = def->vendor_override;
eaa728ee 750 env->cpuid_level = def->level;
59795a1f
AZ		 751 if (def->family > 0x0f)
752 env->cpuid_version = 0xf00 | ((def->family - 0x0f) << 20);
753 else
754 env->cpuid_version = def->family << 8;
755 env->cpuid_version |= ((def->model & 0xf) << 4) | ((def->model >> 4) << 16);
756 env->cpuid_version |= def->stepping;
eaa728ee
FB		 757 env->cpuid_features = def->features;
758 env->pat = 0x0007040600070406ULL;
759 env->cpuid_ext_features = def->ext_features;
760 env->cpuid_ext2_features = def->ext2_features;
761 env->cpuid_xlevel = def->xlevel;
bb0300dc 762 env->cpuid_kvm_features = def->kvm_features;
eaa728ee 763 {
40f8e2fa 764 const char *model_id = def->model_id;
eaa728ee 765 int c, len, i;
40f8e2fa
FB		 766 if (!model_id)
767 model_id = "";
eaa728ee
FB		 768 len = strlen(model_id);
769 for(i = 0; i < 48; i++) {
770 if (i >= len)
771 c = '\0';
772 else
40f8e2fa 773 c = (uint8_t)model_id[i];
eaa728ee
FB		 774 env->cpuid_model[i >> 2] |= c << (8 * (i & 3));
775 }
776 }
7e84c249
FB		 777 return 0;
778}
3b46e624 779
161717d2 780#if !defined(CONFIG_USER_ONLY)
b5ec5ce0 781/* copy vendor id string to 32 bit register, nul pad as needed
782 */
783static void cpyid(const char *s, uint32_t *id)
784{
785 char *d = (char *)id;
786 char i;
787
788 for (i = sizeof (*id); i--; )
789 *d++ = *s ? *s++ : '\0';
790}
791
792/* interpret radix and convert from string to arbitrary scalar,
793 * otherwise flag failure
794 */
795#define setscalar(pval, str, perr) \
796{ \
797 char *pend; \
798 unsigned long ul; \
799 \
800 ul = strtoul(str, &pend, 0); \
801 *str && !*pend ? (*pval = ul) : (*perr = 1); \
802}
803
804/* map cpuid options to feature bits, otherwise return failure
805 * (option tags in *str are delimited by whitespace)
806 */
807static void setfeatures(uint32_t *pval, const char *str,
808 const char **featureset, int *perr)
809{
810 const char *p, *q;
811
812 for (q = p = str; *p || *q; q = p) {
813 while (iswhite(*p))
814 q = ++p;
815 while (*p && !iswhite(*p))
816 ++p;
817 if (!*q && !*p)
818 return;
819 if (!lookup_feature(pval, q, p, featureset)) {
820 fprintf(stderr, "error: feature \"%.*s\" not available in set\n",
821 (int)(p - q), q);
822 *perr = 1;
823 return;
824 }
825 }
826}
827
828/* map config file options to x86_def_t form
829 */
830static int cpudef_setfield(const char *name, const char *str, void *opaque)
831{
832 x86_def_t *def = opaque;
833 int err = 0;
834
835 if (!strcmp(name, "name")) {
836 def->name = strdup(str);
837 } else if (!strcmp(name, "model_id")) {
838 strncpy(def->model_id, str, sizeof (def->model_id));
839 } else if (!strcmp(name, "level")) {
840 setscalar(&def->level, str, &err)
841 } else if (!strcmp(name, "vendor")) {
842 cpyid(&str[0], &def->vendor1);
843 cpyid(&str[4], &def->vendor2);
844 cpyid(&str[8], &def->vendor3);
845 } else if (!strcmp(name, "family")) {
846 setscalar(&def->family, str, &err)
847 } else if (!strcmp(name, "model")) {
848 setscalar(&def->model, str, &err)
849 } else if (!strcmp(name, "stepping")) {
850 setscalar(&def->stepping, str, &err)
851 } else if (!strcmp(name, "feature_edx")) {
852 setfeatures(&def->features, str, feature_name, &err);
853 } else if (!strcmp(name, "feature_ecx")) {
854 setfeatures(&def->ext_features, str, ext_feature_name, &err);
855 } else if (!strcmp(name, "extfeature_edx")) {
856 setfeatures(&def->ext2_features, str, ext2_feature_name, &err);
857 } else if (!strcmp(name, "extfeature_ecx")) {
858 setfeatures(&def->ext3_features, str, ext3_feature_name, &err);
859 } else if (!strcmp(name, "xlevel")) {
860 setscalar(&def->xlevel, str, &err)
861 } else {
862 fprintf(stderr, "error: unknown option [%s = %s]\n", name, str);
863 return (1);
864 }
865 if (err) {
866 fprintf(stderr, "error: bad option value [%s = %s]\n", name, str);
867 return (1);
868 }
869 return (0);
870}
871
872/* register config file entry as x86_def_t
873 */
874static int cpudef_register(QemuOpts *opts, void *opaque)
875{
876 x86_def_t *def = qemu_mallocz(sizeof (x86_def_t));
877
878 qemu_opt_foreach(opts, cpudef_setfield, def, 1);
879 def->next = x86_defs;
880 x86_defs = def;
881 return (0);
882}
161717d2 883#endif /* !CONFIG_USER_ONLY */
b5ec5ce0 884
885/* register "cpudef" models defined in configuration file. Here we first
886 * preload any built-in definitions
887 */
888void x86_cpudef_setup(void)
889{
890 int i;
891
892 for (i = 0; i < ARRAY_SIZE(builtin_x86_defs); ++i) {
893 builtin_x86_defs[i].next = x86_defs;
894 builtin_x86_defs[i].flags = 1;
895 x86_defs = &builtin_x86_defs[i];
896 }
161717d2 897#if !defined(CONFIG_USER_ONLY)
b5ec5ce0 898 qemu_opts_foreach(&qemu_cpudef_opts, cpudef_register, NULL, 0);
899#endif
900}
901
eaa728ee
FB		 902/* NOTE: must be called outside the CPU execute loop */
903void cpu_reset(CPUX86State *env)
7e84c249 904{
eaa728ee 905 int i;
7e84c249 906
eca1bdf4
AL		 907 if (qemu_loglevel_mask(CPU_LOG_RESET)) {
908 qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
909 log_cpu_state(env, X86_DUMP_FPU | X86_DUMP_CCOP);
910 }
911
eaa728ee 912 memset(env, 0, offsetof(CPUX86State, breakpoints));
7e84c249 913
eaa728ee 914 tlb_flush(env, 1);
7e84c249 915
eaa728ee 916 env->old_exception = -1;
7e84c249 917
eaa728ee 918 /* init to reset state */
3b46e624 919
eaa728ee
FB		 920#ifdef CONFIG_SOFTMMU
921 env->hflags |= HF_SOFTMMU_MASK;
2c0262af 922#endif
db620f46 923 env->hflags2 |= HF2_GIF_MASK;
2c0262af 924
eaa728ee
FB		 925 cpu_x86_update_cr0(env, 0x60000010);
926 env->a20_mask = ~0x0;
927 env->smbase = 0x30000;
7e84c249 928
eaa728ee
FB		 929 env->idt.limit = 0xffff;
930 env->gdt.limit = 0xffff;
931 env->ldt.limit = 0xffff;
262ffdae 932 env->ldt.flags = DESC_P_MASK | (2 << DESC_TYPE_SHIFT);
eaa728ee 933 env->tr.limit = 0xffff;
23e6c399 934 env->tr.flags = DESC_P_MASK | (11 << DESC_TYPE_SHIFT);
262ffdae
FB		 935
936 cpu_x86_load_seg_cache(env, R_CS, 0xf000, 0xffff0000, 0xffff,
538f3686
NK		 937 DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK |
938 DESC_R_MASK | DESC_A_MASK);
262ffdae 939 cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffff,
538f3686
NK		 940 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
941 DESC_A_MASK);
262ffdae 942 cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffff,
538f3686
NK		 943 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
944 DESC_A_MASK);
262ffdae 945 cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffff,
538f3686
NK		 946 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
947 DESC_A_MASK);
262ffdae 948 cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffff,
538f3686
NK		 949 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
950 DESC_A_MASK);
262ffdae 951 cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffff,
538f3686
NK		 952 DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
953 DESC_A_MASK);
7e84c249 954
eaa728ee
FB		 955 env->eip = 0xfff0;
956 env->regs[R_EDX] = env->cpuid_version;
2c0262af 957
eaa728ee 958 env->eflags = 0x2;
7e84c249 959
eaa728ee
FB		 960 /* FPU init */
961 for(i = 0;i < 8; i++)
962 env->fptags[i] = 1;
963 env->fpuc = 0x37f;
7e84c249 964
eaa728ee 965 env->mxcsr = 0x1f80;
01df040b
AL		 966
967 memset(env->dr, 0, sizeof(env->dr));
968 env->dr[6] = DR6_FIXED_1;
969 env->dr[7] = DR7_FIXED_1;
970 cpu_breakpoint_remove_all(env, BP_CPU);
971 cpu_watchpoint_remove_all(env, BP_CPU);
af364b41
HY		 972
973 env->mcg_status = 0;
eaa728ee 974}
7e84c249 975
eaa728ee
FB		 976void cpu_x86_close(CPUX86State *env)
977{
bb332cb2 978 qemu_free(env);
eaa728ee 979}
7e84c249 980
eaa728ee
FB		 981/***********************************************************/
982/* x86 debug */
3b46e624 983
eaa728ee
FB		 984static const char *cc_op_str[] = {
985 "DYNAMIC",
986 "EFLAGS",
7e84c249 987
eaa728ee
FB		 988 "MULB",
989 "MULW",
990 "MULL",
991 "MULQ",
3b46e624 992
eaa728ee
FB		 993 "ADDB",
994 "ADDW",
995 "ADDL",
996 "ADDQ",
3b46e624 997
eaa728ee
FB		 998 "ADCB",
999 "ADCW",
1000 "ADCL",
1001 "ADCQ",
3b46e624 1002
eaa728ee
FB		 1003 "SUBB",
1004 "SUBW",
1005 "SUBL",
1006 "SUBQ",
7e84c249 1007
eaa728ee
FB		 1008 "SBBB",
1009 "SBBW",
1010 "SBBL",
1011 "SBBQ",
7e84c249 1012
eaa728ee
FB		 1013 "LOGICB",
1014 "LOGICW",
1015 "LOGICL",
1016 "LOGICQ",
7e84c249 1017
eaa728ee
FB		 1018 "INCB",
1019 "INCW",
1020 "INCL",
1021 "INCQ",
3b46e624 1022
eaa728ee
FB		 1023 "DECB",
1024 "DECW",
1025 "DECL",
1026 "DECQ",
3b46e624 1027
eaa728ee
FB		 1028 "SHLB",
1029 "SHLW",
1030 "SHLL",
1031 "SHLQ",
3b46e624 1032
eaa728ee
FB		 1033 "SARB",
1034 "SARW",
1035 "SARL",
1036 "SARQ",
1037};
7e84c249 1038
a3867ed2
AL		 1039static void
1040cpu_x86_dump_seg_cache(CPUState *env, FILE *f,
1041 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
1042 const char *name, struct SegmentCache *sc)
1043{
1044#ifdef TARGET_X86_64
1045 if (env->hflags & HF_CS64_MASK) {
1046 cpu_fprintf(f, "%-3s=%04x %016" PRIx64 " %08x %08x", name,
1047 sc->selector, sc->base, sc->limit, sc->flags);
1048 } else
1049#endif
1050 {
1051 cpu_fprintf(f, "%-3s=%04x %08x %08x %08x", name, sc->selector,
1052 (uint32_t)sc->base, sc->limit, sc->flags);
1053 }
1054
1055 if (!(env->hflags & HF_PE_MASK) || !(sc->flags & DESC_P_MASK))
1056 goto done;
1057
1058 cpu_fprintf(f, " DPL=%d ", (sc->flags & DESC_DPL_MASK) >> DESC_DPL_SHIFT);
1059 if (sc->flags & DESC_S_MASK) {
1060 if (sc->flags & DESC_CS_MASK) {
1061 cpu_fprintf(f, (sc->flags & DESC_L_MASK) ? "CS64" :
1062 ((sc->flags & DESC_B_MASK) ? "CS32" : "CS16"));
1063 cpu_fprintf(f, " [%c%c", (sc->flags & DESC_C_MASK) ? 'C' : '-',
1064 (sc->flags & DESC_R_MASK) ? 'R' : '-');
1065 } else {
1066 cpu_fprintf(f, (sc->flags & DESC_B_MASK) ? "DS " : "DS16");
1067 cpu_fprintf(f, " [%c%c", (sc->flags & DESC_E_MASK) ? 'E' : '-',
1068 (sc->flags & DESC_W_MASK) ? 'W' : '-');
1069 }
1070 cpu_fprintf(f, "%c]", (sc->flags & DESC_A_MASK) ? 'A' : '-');
1071 } else {
1072 static const char *sys_type_name[2][16] = {
1073 { /* 32 bit mode */
1074 "Reserved", "TSS16-avl", "LDT", "TSS16-busy",
1075 "CallGate16", "TaskGate", "IntGate16", "TrapGate16",
1076 "Reserved", "TSS32-avl", "Reserved", "TSS32-busy",
1077 "CallGate32", "Reserved", "IntGate32", "TrapGate32"
1078 },
1079 { /* 64 bit mode */
1080 "<hiword>", "Reserved", "LDT", "Reserved", "Reserved",
1081 "Reserved", "Reserved", "Reserved", "Reserved",
1082 "TSS64-avl", "Reserved", "TSS64-busy", "CallGate64",
1083 "Reserved", "IntGate64", "TrapGate64"
1084 }
1085 };
1086 cpu_fprintf(f, sys_type_name[(env->hflags & HF_LMA_MASK) ? 1 : 0]
1087 [(sc->flags & DESC_TYPE_MASK)
1088 >> DESC_TYPE_SHIFT]);
1089 }
1090done:
1091 cpu_fprintf(f, "\n");
1092}
1093
eaa728ee
FB		 1094void cpu_dump_state(CPUState *env, FILE *f,
1095 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
1096 int flags)
1097{
1098 int eflags, i, nb;
1099 char cc_op_name[32];
1100 static const char *seg_name[6] = { "ES", "CS", "SS", "DS", "FS", "GS" };
7e84c249 1101
23054111 1102 cpu_synchronize_state(env);
ff3c01ca 1103
eaa728ee
FB		 1104 eflags = env->eflags;
1105#ifdef TARGET_X86_64
1106 if (env->hflags & HF_CS64_MASK) {
1107 cpu_fprintf(f,
1108 "RAX=%016" PRIx64 " RBX=%016" PRIx64 " RCX=%016" PRIx64 " RDX=%016" PRIx64 "\n"
1109 "RSI=%016" PRIx64 " RDI=%016" PRIx64 " RBP=%016" PRIx64 " RSP=%016" PRIx64 "\n"
1110 "R8 =%016" PRIx64 " R9 =%016" PRIx64 " R10=%016" PRIx64 " R11=%016" PRIx64 "\n"
1111 "R12=%016" PRIx64 " R13=%016" PRIx64 " R14=%016" PRIx64 " R15=%016" PRIx64 "\n"
1112 "RIP=%016" PRIx64 " RFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d SMM=%d HLT=%d\n",
1113 env->regs[R_EAX],
1114 env->regs[R_EBX],
1115 env->regs[R_ECX],
1116 env->regs[R_EDX],
1117 env->regs[R_ESI],
1118 env->regs[R_EDI],
1119 env->regs[R_EBP],
1120 env->regs[R_ESP],
1121 env->regs[8],
1122 env->regs[9],
1123 env->regs[10],
1124 env->regs[11],
1125 env->regs[12],
1126 env->regs[13],
1127 env->regs[14],
1128 env->regs[15],
1129 env->eip, eflags,
1130 eflags & DF_MASK ? 'D' : '-',
1131 eflags & CC_O ? 'O' : '-',
1132 eflags & CC_S ? 'S' : '-',
1133 eflags & CC_Z ? 'Z' : '-',
1134 eflags & CC_A ? 'A' : '-',
1135 eflags & CC_P ? 'P' : '-',
1136 eflags & CC_C ? 'C' : '-',
1137 env->hflags & HF_CPL_MASK,
1138 (env->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
5ee0ffaa 1139 (env->a20_mask >> 20) & 1,
eaa728ee 1140 (env->hflags >> HF_SMM_SHIFT) & 1,
ce5232c5 1141 env->halted);
eaa728ee
FB		 1142 } else
1143#endif
1144 {
1145 cpu_fprintf(f, "EAX=%08x EBX=%08x ECX=%08x EDX=%08x\n"
1146 "ESI=%08x EDI=%08x EBP=%08x ESP=%08x\n"
1147 "EIP=%08x EFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d SMM=%d HLT=%d\n",
1148 (uint32_t)env->regs[R_EAX],
1149 (uint32_t)env->regs[R_EBX],
1150 (uint32_t)env->regs[R_ECX],
1151 (uint32_t)env->regs[R_EDX],
1152 (uint32_t)env->regs[R_ESI],
1153 (uint32_t)env->regs[R_EDI],
1154 (uint32_t)env->regs[R_EBP],
1155 (uint32_t)env->regs[R_ESP],
1156 (uint32_t)env->eip, eflags,
1157 eflags & DF_MASK ? 'D' : '-',
1158 eflags & CC_O ? 'O' : '-',
1159 eflags & CC_S ? 'S' : '-',
1160 eflags & CC_Z ? 'Z' : '-',
1161 eflags & CC_A ? 'A' : '-',
1162 eflags & CC_P ? 'P' : '-',
1163 eflags & CC_C ? 'C' : '-',
1164 env->hflags & HF_CPL_MASK,
1165 (env->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
5ee0ffaa 1166 (env->a20_mask >> 20) & 1,
eaa728ee 1167 (env->hflags >> HF_SMM_SHIFT) & 1,
ce5232c5 1168 env->halted);
8145122b 1169 }
3b46e624 1170
a3867ed2
AL		 1171 for(i = 0; i < 6; i++) {
1172 cpu_x86_dump_seg_cache(env, f, cpu_fprintf, seg_name[i],
1173 &env->segs[i]);
1174 }
1175 cpu_x86_dump_seg_cache(env, f, cpu_fprintf, "LDT", &env->ldt);
1176 cpu_x86_dump_seg_cache(env, f, cpu_fprintf, "TR", &env->tr);
1177
eaa728ee
FB		 1178#ifdef TARGET_X86_64
1179 if (env->hflags & HF_LMA_MASK) {
eaa728ee
FB		 1180 cpu_fprintf(f, "GDT= %016" PRIx64 " %08x\n",
1181 env->gdt.base, env->gdt.limit);
1182 cpu_fprintf(f, "IDT= %016" PRIx64 " %08x\n",
1183 env->idt.base, env->idt.limit);
1184 cpu_fprintf(f, "CR0=%08x CR2=%016" PRIx64 " CR3=%016" PRIx64 " CR4=%08x\n",
1185 (uint32_t)env->cr[0],
1186 env->cr[2],
1187 env->cr[3],
1188 (uint32_t)env->cr[4]);
a59cb4e0
AL		 1189 for(i = 0; i < 4; i++)
1190 cpu_fprintf(f, "DR%d=%016" PRIx64 " ", i, env->dr[i]);
1191 cpu_fprintf(f, "\nDR6=%016" PRIx64 " DR7=%016" PRIx64 "\n",
d4b55be5 1192 env->dr[6], env->dr[7]);
eaa728ee
FB		 1193 } else
1194#endif
1195 {
eaa728ee
FB		 1196 cpu_fprintf(f, "GDT= %08x %08x\n",
1197 (uint32_t)env->gdt.base, env->gdt.limit);
1198 cpu_fprintf(f, "IDT= %08x %08x\n",
1199 (uint32_t)env->idt.base, env->idt.limit);
1200 cpu_fprintf(f, "CR0=%08x CR2=%08x CR3=%08x CR4=%08x\n",
1201 (uint32_t)env->cr[0],
1202 (uint32_t)env->cr[2],
1203 (uint32_t)env->cr[3],
1204 (uint32_t)env->cr[4]);
a59cb4e0
AL		 1205 for(i = 0; i < 4; i++)
1206 cpu_fprintf(f, "DR%d=%08x ", i, env->dr[i]);
d4b55be5 1207 cpu_fprintf(f, "\nDR6=%08x DR7=%08x\n", env->dr[6], env->dr[7]);
eaa728ee
FB		 1208 }
1209 if (flags & X86_DUMP_CCOP) {
1210 if ((unsigned)env->cc_op < CC_OP_NB)
1211 snprintf(cc_op_name, sizeof(cc_op_name), "%s", cc_op_str[env->cc_op]);
1212 else
1213 snprintf(cc_op_name, sizeof(cc_op_name), "[%d]", env->cc_op);
1214#ifdef TARGET_X86_64
1215 if (env->hflags & HF_CS64_MASK) {
1216 cpu_fprintf(f, "CCS=%016" PRIx64 " CCD=%016" PRIx64 " CCO=%-8s\n",
1217 env->cc_src, env->cc_dst,
1218 cc_op_name);
1219 } else
1220#endif
1221 {
1222 cpu_fprintf(f, "CCS=%08x CCD=%08x CCO=%-8s\n",
1223 (uint32_t)env->cc_src, (uint32_t)env->cc_dst,
1224 cc_op_name);
1225 }
7e84c249 1226 }
eaa728ee
FB		 1227 if (flags & X86_DUMP_FPU) {
1228 int fptag;
1229 fptag = 0;
1230 for(i = 0; i < 8; i++) {
1231 fptag |= ((!env->fptags[i]) << i);
1232 }
1233 cpu_fprintf(f, "FCW=%04x FSW=%04x [ST=%d] FTW=%02x MXCSR=%08x\n",
1234 env->fpuc,
1235 (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11,
1236 env->fpstt,
1237 fptag,
1238 env->mxcsr);
1239 for(i=0;i<8;i++) {
1240#if defined(USE_X86LDOUBLE)
1241 union {
1242 long double d;
1243 struct {
1244 uint64_t lower;
1245 uint16_t upper;
1246 } l;
1247 } tmp;
1248 tmp.d = env->fpregs[i].d;
1249 cpu_fprintf(f, "FPR%d=%016" PRIx64 " %04x",
1250 i, tmp.l.lower, tmp.l.upper);
1251#else
1252 cpu_fprintf(f, "FPR%d=%016" PRIx64,
1253 i, env->fpregs[i].mmx.q);
1254#endif
1255 if ((i & 1) == 1)
1256 cpu_fprintf(f, "\n");
1257 else
1258 cpu_fprintf(f, " ");
1259 }
1260 if (env->hflags & HF_CS64_MASK)
1261 nb = 16;
1262 else
1263 nb = 8;
1264 for(i=0;i<nb;i++) {
1265 cpu_fprintf(f, "XMM%02d=%08x%08x%08x%08x",
1266 i,
1267 env->xmm_regs[i].XMM_L(3),
1268 env->xmm_regs[i].XMM_L(2),
1269 env->xmm_regs[i].XMM_L(1),
1270 env->xmm_regs[i].XMM_L(0));
1271 if ((i & 1) == 1)
1272 cpu_fprintf(f, "\n");
1273 else
1274 cpu_fprintf(f, " ");
1275 }
7e84c249 1276 }
2c0262af 1277}
7e84c249 1278
eaa728ee
FB		 1279/***********************************************************/
1280/* x86 mmu */
1281/* XXX: add PGE support */
1282
1283void cpu_x86_set_a20(CPUX86State *env, int a20_state)
2c0262af 1284{
eaa728ee
FB		 1285 a20_state = (a20_state != 0);
1286 if (a20_state != ((env->a20_mask >> 20) & 1)) {
1287#if defined(DEBUG_MMU)
1288 printf("A20 update: a20=%d\n", a20_state);
1289#endif
1290 /* if the cpu is currently executing code, we must unlink it and
1291 all the potentially executing TB */
1292 cpu_interrupt(env, CPU_INTERRUPT_EXITTB);
3b46e624 1293
eaa728ee
FB		 1294 /* when a20 is changed, all the MMU mappings are invalid, so
1295 we must flush everything */
1296 tlb_flush(env, 1);
5ee0ffaa 1297 env->a20_mask = ~(1 << 20) | (a20_state << 20);
7e84c249 1298 }
2c0262af
FB		 1299}
1300
eaa728ee 1301void cpu_x86_update_cr0(CPUX86State *env, uint32_t new_cr0)
2c0262af 1302{
eaa728ee 1303 int pe_state;
2c0262af 1304
eaa728ee
FB		 1305#if defined(DEBUG_MMU)
1306 printf("CR0 update: CR0=0x%08x\n", new_cr0);
1307#endif
1308 if ((new_cr0 & (CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK)) !=
1309 (env->cr[0] & (CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK))) {
1310 tlb_flush(env, 1);
1311 }
2c0262af 1312
eaa728ee
FB		 1313#ifdef TARGET_X86_64
1314 if (!(env->cr[0] & CR0_PG_MASK) && (new_cr0 & CR0_PG_MASK) &&
1315 (env->efer & MSR_EFER_LME)) {
1316 /* enter in long mode */
1317 /* XXX: generate an exception */
1318 if (!(env->cr[4] & CR4_PAE_MASK))
1319 return;
1320 env->efer |= MSR_EFER_LMA;
1321 env->hflags |= HF_LMA_MASK;
1322 } else if ((env->cr[0] & CR0_PG_MASK) && !(new_cr0 & CR0_PG_MASK) &&
1323 (env->efer & MSR_EFER_LMA)) {
1324 /* exit long mode */
1325 env->efer &= ~MSR_EFER_LMA;
1326 env->hflags &= ~(HF_LMA_MASK | HF_CS64_MASK);
1327 env->eip &= 0xffffffff;
1328 }
1329#endif
1330 env->cr[0] = new_cr0 | CR0_ET_MASK;
7e84c249 1331
eaa728ee
FB		 1332 /* update PE flag in hidden flags */
1333 pe_state = (env->cr[0] & CR0_PE_MASK);
1334 env->hflags = (env->hflags & ~HF_PE_MASK) | (pe_state << HF_PE_SHIFT);
1335 /* ensure that ADDSEG is always set in real mode */
1336 env->hflags |= ((pe_state ^ 1) << HF_ADDSEG_SHIFT);
1337 /* update FPU flags */
1338 env->hflags = (env->hflags & ~(HF_MP_MASK | HF_EM_MASK | HF_TS_MASK)) |
1339 ((new_cr0 << (HF_MP_SHIFT - 1)) & (HF_MP_MASK | HF_EM_MASK | HF_TS_MASK));
7e84c249
FB		 1340}
1341
eaa728ee
FB		 1342/* XXX: in legacy PAE mode, generate a GPF if reserved bits are set in
1343 the PDPT */
1344void cpu_x86_update_cr3(CPUX86State *env, target_ulong new_cr3)
7e84c249 1345{
eaa728ee
FB		 1346 env->cr[3] = new_cr3;
1347 if (env->cr[0] & CR0_PG_MASK) {
1348#if defined(DEBUG_MMU)
1349 printf("CR3 update: CR3=" TARGET_FMT_lx "\n", new_cr3);
1350#endif
1351 tlb_flush(env, 0);
1352 }
7e84c249
FB		 1353}
1354
eaa728ee 1355void cpu_x86_update_cr4(CPUX86State *env, uint32_t new_cr4)
7e84c249 1356{
eaa728ee
FB		 1357#if defined(DEBUG_MMU)
1358 printf("CR4 update: CR4=%08x\n", (uint32_t)env->cr[4]);
1359#endif
1360 if ((new_cr4 & (CR4_PGE_MASK | CR4_PAE_MASK | CR4_PSE_MASK)) !=
1361 (env->cr[4] & (CR4_PGE_MASK | CR4_PAE_MASK | CR4_PSE_MASK))) {
1362 tlb_flush(env, 1);
1363 }
1364 /* SSE handling */
1365 if (!(env->cpuid_features & CPUID_SSE))
1366 new_cr4 &= ~CR4_OSFXSR_MASK;
1367 if (new_cr4 & CR4_OSFXSR_MASK)
1368 env->hflags |= HF_OSFXSR_MASK;
1369 else
1370 env->hflags &= ~HF_OSFXSR_MASK;
b8b6a50b 1371
eaa728ee 1372 env->cr[4] = new_cr4;
b8b6a50b
FB		 1373}
1374
eaa728ee
FB		 1375#if defined(CONFIG_USER_ONLY)
1376
1377int cpu_x86_handle_mmu_fault(CPUX86State *env, target_ulong addr,
1378 int is_write, int mmu_idx, int is_softmmu)
b8b6a50b 1379{
eaa728ee
FB		 1380 /* user mode only emulation */
1381 is_write &= 1;
1382 env->cr[2] = addr;
1383 env->error_code = (is_write << PG_ERROR_W_BIT);
1384 env->error_code |= PG_ERROR_U_MASK;
1385 env->exception_index = EXCP0E_PAGE;
1386 return 1;
2c0262af
FB		 1387}
1388
c227f099 1389target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr)
891b38e4 1390{
eaa728ee 1391 return addr;
891b38e4
FB		 1392}
1393
8d7b0fbb 1394#else
891b38e4 1395
eaa728ee
FB		 1396/* XXX: This value should match the one returned by CPUID
1397 * and in exec.c */
eaa728ee 1398# if defined(TARGET_X86_64)
2c90d794 1399# define PHYS_ADDR_MASK 0xfffffff000LL
eaa728ee 1400# else
2c90d794 1401# define PHYS_ADDR_MASK 0xffffff000LL
eaa728ee 1402# endif
eaa728ee
FB		 1403
1404/* return value:
1405 -1 = cannot handle fault
1406 0 = nothing more to do
1407 1 = generate PF fault
1408 2 = soft MMU activation required for this block
1409*/
1410int cpu_x86_handle_mmu_fault(CPUX86State *env, target_ulong addr,
1411 int is_write1, int mmu_idx, int is_softmmu)
1412{
1413 uint64_t ptep, pte;
1414 target_ulong pde_addr, pte_addr;
1415 int error_code, is_dirty, prot, page_size, ret, is_write, is_user;
c227f099 1416 target_phys_addr_t paddr;
eaa728ee
FB		 1417 uint32_t page_offset;
1418 target_ulong vaddr, virt_addr;
1419
1420 is_user = mmu_idx == MMU_USER_IDX;
1421#if defined(DEBUG_MMU)
1422 printf("MMU fault: addr=" TARGET_FMT_lx " w=%d u=%d eip=" TARGET_FMT_lx "\n",
1423 addr, is_write1, is_user, env->eip);
1424#endif
1425 is_write = is_write1 & 1;
1426
1427 if (!(env->cr[0] & CR0_PG_MASK)) {
1428 pte = addr;
1429 virt_addr = addr & TARGET_PAGE_MASK;
1430 prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
1431 page_size = 4096;
1432 goto do_mapping;
1433 }
1434
1435 if (env->cr[4] & CR4_PAE_MASK) {
1436 uint64_t pde, pdpe;
1437 target_ulong pdpe_addr;
2c0262af 1438
eaa728ee
FB		 1439#ifdef TARGET_X86_64
1440 if (env->hflags & HF_LMA_MASK) {
1441 uint64_t pml4e_addr, pml4e;
1442 int32_t sext;
1443
1444 /* test virtual address sign extension */
1445 sext = (int64_t)addr >> 47;
1446 if (sext != 0 && sext != -1) {
1447 env->error_code = 0;
1448 env->exception_index = EXCP0D_GPF;
1449 return 1;
1450 }
0573fbfc 1451
eaa728ee
FB		 1452 pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) &
1453 env->a20_mask;
1454 pml4e = ldq_phys(pml4e_addr);
1455 if (!(pml4e & PG_PRESENT_MASK)) {
1456 error_code = 0;
1457 goto do_fault;
1458 }
1459 if (!(env->efer & MSR_EFER_NXE) && (pml4e & PG_NX_MASK)) {
1460 error_code = PG_ERROR_RSVD_MASK;
1461 goto do_fault;
1462 }
1463 if (!(pml4e & PG_ACCESSED_MASK)) {
1464 pml4e |= PG_ACCESSED_MASK;
1465 stl_phys_notdirty(pml4e_addr, pml4e);
1466 }
1467 ptep = pml4e ^ PG_NX_MASK;
1468 pdpe_addr = ((pml4e & PHYS_ADDR_MASK) + (((addr >> 30) & 0x1ff) << 3)) &
1469 env->a20_mask;
1470 pdpe = ldq_phys(pdpe_addr);
1471 if (!(pdpe & PG_PRESENT_MASK)) {
1472 error_code = 0;
1473 goto do_fault;
1474 }
1475 if (!(env->efer & MSR_EFER_NXE) && (pdpe & PG_NX_MASK)) {
1476 error_code = PG_ERROR_RSVD_MASK;
1477 goto do_fault;
1478 }
1479 ptep &= pdpe ^ PG_NX_MASK;
1480 if (!(pdpe & PG_ACCESSED_MASK)) {
1481 pdpe |= PG_ACCESSED_MASK;
1482 stl_phys_notdirty(pdpe_addr, pdpe);
1483 }
1484 } else
1485#endif
1486 {
1487 /* XXX: load them when cr3 is loaded ? */
1488 pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) &
1489 env->a20_mask;
1490 pdpe = ldq_phys(pdpe_addr);
1491 if (!(pdpe & PG_PRESENT_MASK)) {
1492 error_code = 0;
1493 goto do_fault;
1494 }
1495 ptep = PG_NX_MASK | PG_USER_MASK | PG_RW_MASK;
7e84c249 1496 }
7e84c249 1497
eaa728ee
FB		 1498 pde_addr = ((pdpe & PHYS_ADDR_MASK) + (((addr >> 21) & 0x1ff) << 3)) &
1499 env->a20_mask;
1500 pde = ldq_phys(pde_addr);
1501 if (!(pde & PG_PRESENT_MASK)) {
1502 error_code = 0;
1503 goto do_fault;
1504 }
1505 if (!(env->efer & MSR_EFER_NXE) && (pde & PG_NX_MASK)) {
1506 error_code = PG_ERROR_RSVD_MASK;
1507 goto do_fault;
1508 }
1509 ptep &= pde ^ PG_NX_MASK;
1510 if (pde & PG_PSE_MASK) {
1511 /* 2 MB page */
1512 page_size = 2048 * 1024;
1513 ptep ^= PG_NX_MASK;
1514 if ((ptep & PG_NX_MASK) && is_write1 == 2)
1515 goto do_fault_protect;
1516 if (is_user) {
1517 if (!(ptep & PG_USER_MASK))
1518 goto do_fault_protect;
1519 if (is_write && !(ptep & PG_RW_MASK))
1520 goto do_fault_protect;
1521 } else {
1522 if ((env->cr[0] & CR0_WP_MASK) &&
1523 is_write && !(ptep & PG_RW_MASK))
1524 goto do_fault_protect;
1525 }
1526 is_dirty = is_write && !(pde & PG_DIRTY_MASK);
1527 if (!(pde & PG_ACCESSED_MASK) || is_dirty) {
1528 pde |= PG_ACCESSED_MASK;
1529 if (is_dirty)
1530 pde |= PG_DIRTY_MASK;
1531 stl_phys_notdirty(pde_addr, pde);
1532 }
1533 /* align to page_size */
1534 pte = pde & ((PHYS_ADDR_MASK & ~(page_size - 1)) | 0xfff);
1535 virt_addr = addr & ~(page_size - 1);
1536 } else {
1537 /* 4 KB page */
1538 if (!(pde & PG_ACCESSED_MASK)) {
1539 pde |= PG_ACCESSED_MASK;
1540 stl_phys_notdirty(pde_addr, pde);
1541 }
1542 pte_addr = ((pde & PHYS_ADDR_MASK) + (((addr >> 12) & 0x1ff) << 3)) &
1543 env->a20_mask;
1544 pte = ldq_phys(pte_addr);
1545 if (!(pte & PG_PRESENT_MASK)) {
1546 error_code = 0;
1547 goto do_fault;
1548 }
1549 if (!(env->efer & MSR_EFER_NXE) && (pte & PG_NX_MASK)) {
1550 error_code = PG_ERROR_RSVD_MASK;
1551 goto do_fault;
1552 }
1553 /* combine pde and pte nx, user and rw protections */
1554 ptep &= pte ^ PG_NX_MASK;
1555 ptep ^= PG_NX_MASK;
1556 if ((ptep & PG_NX_MASK) && is_write1 == 2)
1557 goto do_fault_protect;
1558 if (is_user) {
1559 if (!(ptep & PG_USER_MASK))
1560 goto do_fault_protect;
1561 if (is_write && !(ptep & PG_RW_MASK))
1562 goto do_fault_protect;
1563 } else {
1564 if ((env->cr[0] & CR0_WP_MASK) &&
1565 is_write && !(ptep & PG_RW_MASK))
1566 goto do_fault_protect;
1567 }
1568 is_dirty = is_write && !(pte & PG_DIRTY_MASK);
1569 if (!(pte & PG_ACCESSED_MASK) || is_dirty) {
1570 pte |= PG_ACCESSED_MASK;
1571 if (is_dirty)
1572 pte |= PG_DIRTY_MASK;
1573 stl_phys_notdirty(pte_addr, pte);
1574 }
1575 page_size = 4096;
1576 virt_addr = addr & ~0xfff;
1577 pte = pte & (PHYS_ADDR_MASK | 0xfff);
7e84c249 1578 }
2c0262af 1579 } else {
eaa728ee
FB		 1580 uint32_t pde;
1581
1582 /* page directory entry */
1583 pde_addr = ((env->cr[3] & ~0xfff) + ((addr >> 20) & 0xffc)) &
1584 env->a20_mask;
1585 pde = ldl_phys(pde_addr);
1586 if (!(pde & PG_PRESENT_MASK)) {
1587 error_code = 0;
1588 goto do_fault;
1589 }
1590 /* if PSE bit is set, then we use a 4MB page */
1591 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1592 page_size = 4096 * 1024;
1593 if (is_user) {
1594 if (!(pde & PG_USER_MASK))
1595 goto do_fault_protect;
1596 if (is_write && !(pde & PG_RW_MASK))
1597 goto do_fault_protect;
1598 } else {
1599 if ((env->cr[0] & CR0_WP_MASK) &&
1600 is_write && !(pde & PG_RW_MASK))
1601 goto do_fault_protect;
1602 }
1603 is_dirty = is_write && !(pde & PG_DIRTY_MASK);
1604 if (!(pde & PG_ACCESSED_MASK) || is_dirty) {
1605 pde |= PG_ACCESSED_MASK;
1606 if (is_dirty)
1607 pde |= PG_DIRTY_MASK;
1608 stl_phys_notdirty(pde_addr, pde);
1609 }
2c0262af 1610
eaa728ee
FB		 1611 pte = pde & ~( (page_size - 1) & ~0xfff); /* align to page_size */
1612 ptep = pte;
1613 virt_addr = addr & ~(page_size - 1);
1614 } else {
1615 if (!(pde & PG_ACCESSED_MASK)) {
1616 pde |= PG_ACCESSED_MASK;
1617 stl_phys_notdirty(pde_addr, pde);
1618 }
891b38e4 1619
eaa728ee
FB		 1620 /* page directory entry */
1621 pte_addr = ((pde & ~0xfff) + ((addr >> 10) & 0xffc)) &
1622 env->a20_mask;
1623 pte = ldl_phys(pte_addr);
1624 if (!(pte & PG_PRESENT_MASK)) {
1625 error_code = 0;
1626 goto do_fault;
8e682019 1627 }
eaa728ee
FB		 1628 /* combine pde and pte user and rw protections */
1629 ptep = pte & pde;
1630 if (is_user) {
1631 if (!(ptep & PG_USER_MASK))
1632 goto do_fault_protect;
1633 if (is_write && !(ptep & PG_RW_MASK))
1634 goto do_fault_protect;
1635 } else {
1636 if ((env->cr[0] & CR0_WP_MASK) &&
1637 is_write && !(ptep & PG_RW_MASK))
1638 goto do_fault_protect;
8e682019 1639 }
eaa728ee
FB		 1640 is_dirty = is_write && !(pte & PG_DIRTY_MASK);
1641 if (!(pte & PG_ACCESSED_MASK) || is_dirty) {
1642 pte |= PG_ACCESSED_MASK;
1643 if (is_dirty)
1644 pte |= PG_DIRTY_MASK;
1645 stl_phys_notdirty(pte_addr, pte);
1646 }
1647 page_size = 4096;
1648 virt_addr = addr & ~0xfff;
2c0262af
FB		 1649 }
1650 }
eaa728ee
FB		 1651 /* the page can be put in the TLB */
1652 prot = PAGE_READ;
1653 if (!(ptep & PG_NX_MASK))
1654 prot |= PAGE_EXEC;
1655 if (pte & PG_DIRTY_MASK) {
1656 /* only set write access if already dirty... otherwise wait
1657 for dirty access */
1658 if (is_user) {
1659 if (ptep & PG_RW_MASK)
1660 prot |= PAGE_WRITE;
1661 } else {
1662 if (!(env->cr[0] & CR0_WP_MASK) ||
1663 (ptep & PG_RW_MASK))
1664 prot |= PAGE_WRITE;
8e682019 1665 }
891b38e4 1666 }
eaa728ee
FB		 1667 do_mapping:
1668 pte = pte & env->a20_mask;
1669
1670 /* Even if 4MB pages, we map only one 4KB page in the cache to
1671 avoid filling it too fast */
1672 page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1);
1673 paddr = (pte & TARGET_PAGE_MASK) + page_offset;
1674 vaddr = virt_addr + page_offset;
1675
1676 ret = tlb_set_page_exec(env, vaddr, paddr, prot, mmu_idx, is_softmmu);
1677 return ret;
1678 do_fault_protect:
1679 error_code = PG_ERROR_P_MASK;
1680 do_fault:
1681 error_code |= (is_write << PG_ERROR_W_BIT);
1682 if (is_user)
1683 error_code |= PG_ERROR_U_MASK;
1684 if (is_write1 == 2 &&
1685 (env->efer & MSR_EFER_NXE) &&
1686 (env->cr[4] & CR4_PAE_MASK))
1687 error_code |= PG_ERROR_I_D_MASK;
872929aa
FB		 1688 if (env->intercept_exceptions & (1 << EXCP0E_PAGE)) {
1689 /* cr2 is not modified in case of exceptions */
1690 stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2),
1691 addr);
eaa728ee
FB		 1692 } else {
1693 env->cr[2] = addr;
2c0262af 1694 }
eaa728ee
FB		 1695 env->error_code = error_code;
1696 env->exception_index = EXCP0E_PAGE;
eaa728ee 1697 return 1;
14ce26e7
FB		 1698}
1699
c227f099 1700target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr)
14ce26e7 1701{
eaa728ee
FB		 1702 target_ulong pde_addr, pte_addr;
1703 uint64_t pte;
c227f099 1704 target_phys_addr_t paddr;
eaa728ee
FB		 1705 uint32_t page_offset;
1706 int page_size;
14ce26e7 1707
eaa728ee
FB		 1708 if (env->cr[4] & CR4_PAE_MASK) {
1709 target_ulong pdpe_addr;
1710 uint64_t pde, pdpe;
14ce26e7 1711
eaa728ee
FB		 1712#ifdef TARGET_X86_64
1713 if (env->hflags & HF_LMA_MASK) {
1714 uint64_t pml4e_addr, pml4e;
1715 int32_t sext;
1716
1717 /* test virtual address sign extension */
1718 sext = (int64_t)addr >> 47;
1719 if (sext != 0 && sext != -1)
1720 return -1;
1721
1722 pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) &
1723 env->a20_mask;
1724 pml4e = ldq_phys(pml4e_addr);
1725 if (!(pml4e & PG_PRESENT_MASK))
1726 return -1;
1727
1728 pdpe_addr = ((pml4e & ~0xfff) + (((addr >> 30) & 0x1ff) << 3)) &
1729 env->a20_mask;
1730 pdpe = ldq_phys(pdpe_addr);
1731 if (!(pdpe & PG_PRESENT_MASK))
1732 return -1;
1733 } else
1734#endif
1735 {
1736 pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) &
1737 env->a20_mask;
1738 pdpe = ldq_phys(pdpe_addr);
1739 if (!(pdpe & PG_PRESENT_MASK))
1740 return -1;
14ce26e7 1741 }
14ce26e7 1742
eaa728ee
FB		 1743 pde_addr = ((pdpe & ~0xfff) + (((addr >> 21) & 0x1ff) << 3)) &
1744 env->a20_mask;
1745 pde = ldq_phys(pde_addr);
1746 if (!(pde & PG_PRESENT_MASK)) {
1747 return -1;
1748 }
1749 if (pde & PG_PSE_MASK) {
1750 /* 2 MB page */
1751 page_size = 2048 * 1024;
1752 pte = pde & ~( (page_size - 1) & ~0xfff); /* align to page_size */
1753 } else {
1754 /* 4 KB page */
1755 pte_addr = ((pde & ~0xfff) + (((addr >> 12) & 0x1ff) << 3)) &
1756 env->a20_mask;
1757 page_size = 4096;
1758 pte = ldq_phys(pte_addr);
1759 }
ca1c9e15
AL		 1760 if (!(pte & PG_PRESENT_MASK))
1761 return -1;
14ce26e7 1762 } else {
eaa728ee 1763 uint32_t pde;
3b46e624 1764
eaa728ee
FB		 1765 if (!(env->cr[0] & CR0_PG_MASK)) {
1766 pte = addr;
1767 page_size = 4096;
1768 } else {
1769 /* page directory entry */
1770 pde_addr = ((env->cr[3] & ~0xfff) + ((addr >> 20) & 0xffc)) & env->a20_mask;
1771 pde = ldl_phys(pde_addr);
1772 if (!(pde & PG_PRESENT_MASK))
1773 return -1;
1774 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1775 pte = pde & ~0x003ff000; /* align to 4MB */
1776 page_size = 4096 * 1024;
1777 } else {
1778 /* page directory entry */
1779 pte_addr = ((pde & ~0xfff) + ((addr >> 10) & 0xffc)) & env->a20_mask;
1780 pte = ldl_phys(pte_addr);
1781 if (!(pte & PG_PRESENT_MASK))
1782 return -1;
1783 page_size = 4096;
1784 }
1785 }
1786 pte = pte & env->a20_mask;
14ce26e7 1787 }
14ce26e7 1788
eaa728ee
FB		 1789 page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1);
1790 paddr = (pte & TARGET_PAGE_MASK) + page_offset;
1791 return paddr;
3b21e03e 1792}
01df040b
AL		 1793
1794void hw_breakpoint_insert(CPUState *env, int index)
1795{
1796 int type, err = 0;
1797
1798 switch (hw_breakpoint_type(env->dr[7], index)) {
1799 case 0:
1800 if (hw_breakpoint_enabled(env->dr[7], index))
1801 err = cpu_breakpoint_insert(env, env->dr[index], BP_CPU,
1802 &env->cpu_breakpoint[index]);
1803 break;
1804 case 1:
1805 type = BP_CPU | BP_MEM_WRITE;
1806 goto insert_wp;
1807 case 2:
1808 /* No support for I/O watchpoints yet */
1809 break;
1810 case 3:
1811 type = BP_CPU | BP_MEM_ACCESS;
1812 insert_wp:
1813 err = cpu_watchpoint_insert(env, env->dr[index],
1814 hw_breakpoint_len(env->dr[7], index),
1815 type, &env->cpu_watchpoint[index]);
1816 break;
1817 }
1818 if (err)
1819 env->cpu_breakpoint[index] = NULL;
1820}
1821
1822void hw_breakpoint_remove(CPUState *env, int index)
1823{
1824 if (!env->cpu_breakpoint[index])
1825 return;
1826 switch (hw_breakpoint_type(env->dr[7], index)) {
1827 case 0:
1828 if (hw_breakpoint_enabled(env->dr[7], index))
1829 cpu_breakpoint_remove_by_ref(env, env->cpu_breakpoint[index]);
1830 break;
1831 case 1:
1832 case 3:
1833 cpu_watchpoint_remove_by_ref(env, env->cpu_watchpoint[index]);
1834 break;
1835 case 2:
1836 /* No support for I/O watchpoints yet */
1837 break;
1838 }
1839}
1840
1841int check_hw_breakpoints(CPUState *env, int force_dr6_update)
1842{
1843 target_ulong dr6;
1844 int reg, type;
1845 int hit_enabled = 0;
1846
1847 dr6 = env->dr[6] & ~0xf;
1848 for (reg = 0; reg < 4; reg++) {
1849 type = hw_breakpoint_type(env->dr[7], reg);
1850 if ((type == 0 && env->dr[reg] == env->eip) ||
1851 ((type & 1) && env->cpu_watchpoint[reg] &&
1852 (env->cpu_watchpoint[reg]->flags & BP_WATCHPOINT_HIT))) {
1853 dr6 |= 1 << reg;
1854 if (hw_breakpoint_enabled(env->dr[7], reg))
1855 hit_enabled = 1;
1856 }
1857 }
1858 if (hit_enabled || force_dr6_update)
1859 env->dr[6] = dr6;
1860 return hit_enabled;
1861}
1862
1863static CPUDebugExcpHandler *prev_debug_excp_handler;
1864
63a54736 1865void raise_exception_env(int exception_index, CPUState *env);
01df040b
AL		 1866
1867static void breakpoint_handler(CPUState *env)
1868{
1869 CPUBreakpoint *bp;
1870
1871 if (env->watchpoint_hit) {
1872 if (env->watchpoint_hit->flags & BP_CPU) {
1873 env->watchpoint_hit = NULL;
1874 if (check_hw_breakpoints(env, 0))
63a54736 1875 raise_exception_env(EXCP01_DB, env);
01df040b
AL		 1876 else
1877 cpu_resume_from_signal(env, NULL);
1878 }
1879 } else {
72cf2d4f 1880 QTAILQ_FOREACH(bp, &env->breakpoints, entry)
01df040b
AL		 1881 if (bp->pc == env->eip) {
1882 if (bp->flags & BP_CPU) {
1883 check_hw_breakpoints(env, 1);
63a54736 1884 raise_exception_env(EXCP01_DB, env);
01df040b
AL		 1885 }
1886 break;
1887 }
1888 }
1889 if (prev_debug_excp_handler)
1890 prev_debug_excp_handler(env);
1891}
79c4f6b0
HY		 1892
1893/* This should come from sysemu.h - if we could include it here... */
1894void qemu_system_reset_request(void);
1895
1896void cpu_inject_x86_mce(CPUState *cenv, int bank, uint64_t status,
1897 uint64_t mcg_status, uint64_t addr, uint64_t misc)
1898{
1899 uint64_t mcg_cap = cenv->mcg_cap;
1900 unsigned bank_num = mcg_cap & 0xff;
1901 uint64_t *banks = cenv->mce_banks;
1902
1903 if (bank >= bank_num || !(status & MCI_STATUS_VAL))
1904 return;
1905
1906 /*
1907 * if MSR_MCG_CTL is not all 1s, the uncorrected error
1908 * reporting is disabled
1909 */
1910 if ((status & MCI_STATUS_UC) && (mcg_cap & MCG_CTL_P) &&
1911 cenv->mcg_ctl != ~(uint64_t)0)
1912 return;
1913 banks += 4 * bank;
1914 /*
1915 * if MSR_MCi_CTL is not all 1s, the uncorrected error
1916 * reporting is disabled for the bank
1917 */
1918 if ((status & MCI_STATUS_UC) && banks[0] != ~(uint64_t)0)
1919 return;
1920 if (status & MCI_STATUS_UC) {
1921 if ((cenv->mcg_status & MCG_STATUS_MCIP) ||
1922 !(cenv->cr[4] & CR4_MCE_MASK)) {
1923 fprintf(stderr, "injects mce exception while previous "
1924 "one is in progress!\n");
1925 qemu_log_mask(CPU_LOG_RESET, "Triple fault\n");
1926 qemu_system_reset_request();
1927 return;
1928 }
1929 if (banks[1] & MCI_STATUS_VAL)
1930 status |= MCI_STATUS_OVER;
1931 banks[2] = addr;
1932 banks[3] = misc;
1933 cenv->mcg_status = mcg_status;
1934 banks[1] = status;
1935 cpu_interrupt(cenv, CPU_INTERRUPT_MCE);
1936 } else if (!(banks[1] & MCI_STATUS_VAL)
1937 || !(banks[1] & MCI_STATUS_UC)) {
1938 if (banks[1] & MCI_STATUS_VAL)
1939 status |= MCI_STATUS_OVER;
1940 banks[2] = addr;
1941 banks[3] = misc;
1942 banks[1] = status;
1943 } else
1944 banks[1] |= MCI_STATUS_OVER;
1945}
74ce674f 1946#endif /* !CONFIG_USER_ONLY */
6fd805e1 1947
79c4f6b0
HY		 1948static void mce_init(CPUX86State *cenv)
1949{
1950 unsigned int bank, bank_num;
1951
1952 if (((cenv->cpuid_version >> 8)&0xf) >= 6
1953 && (cenv->cpuid_features&(CPUID_MCE|CPUID_MCA)) == (CPUID_MCE|CPUID_MCA)) {
1954 cenv->mcg_cap = MCE_CAP_DEF | MCE_BANKS_DEF;
1955 cenv->mcg_ctl = ~(uint64_t)0;
ac74d0f1 1956 bank_num = MCE_BANKS_DEF;
79c4f6b0
HY		 1957 for (bank = 0; bank < bank_num; bank++)
1958 cenv->mce_banks[bank*4] = ~(uint64_t)0;
1959 }
1960}
1961
e00b6f80
AL		 1962static void host_cpuid(uint32_t function, uint32_t count,
1963 uint32_t *eax, uint32_t *ebx,
7ba1e619
AL		 1964 uint32_t *ecx, uint32_t *edx)
1965{
10781c09 1966#if defined(CONFIG_KVM)
7ba1e619
AL		 1967 uint32_t vec[4];
1968
1969#ifdef __x86_64__
1970 asm volatile("cpuid"
e00b6f80
AL		 1971 : "=a"(vec[0]), "=b"(vec[1]),
1972 "=c"(vec[2]), "=d"(vec[3])
1973 : "0"(function), "c"(count) : "cc");
7ba1e619
AL		 1974#else
1975 asm volatile("pusha \n\t"
e00b6f80 1976 "cpuid \n\t"
b36d24b6
AL		 1977 "mov %%eax, 0(%2) \n\t"
1978 "mov %%ebx, 4(%2) \n\t"
1979 "mov %%ecx, 8(%2) \n\t"
1980 "mov %%edx, 12(%2) \n\t"
e00b6f80
AL		 1981 "popa"
1982 : : "a"(function), "c"(count), "S"(vec)
1983 : "memory", "cc");
7ba1e619
AL		 1984#endif
1985
1986 if (eax)
1987 *eax = vec[0];
1988 if (ebx)
1989 *ebx = vec[1];
1990 if (ecx)
1991 *ecx = vec[2];
1992 if (edx)
1993 *edx = vec[3];
7ba1e619 1994#endif
10781c09 1995}
7ba1e619 1996
6d9fef1a
AP		 1997static void get_cpuid_vendor(CPUX86State *env, uint32_t *ebx,
1998 uint32_t *ecx, uint32_t *edx)
1999{
2000 *ebx = env->cpuid_vendor1;
2001 *edx = env->cpuid_vendor2;
2002 *ecx = env->cpuid_vendor3;
2003
2004 /* sysenter isn't supported on compatibility mode on AMD, syscall
2005 * isn't supported in compatibility mode on Intel.
2006 * Normally we advertise the actual cpu vendor, but you can override
2007 * this if you want to use KVM's sysenter/syscall emulation
2008 * in compatibility mode and when doing cross vendor migration
2009 */
2010 if (kvm_enabled() && env->cpuid_vendor_override) {
2011 host_cpuid(0, 0, NULL, ebx, ecx, edx);
2012 }
2013}
2014
e00b6f80 2015void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
6fd805e1
AL		 2016 uint32_t *eax, uint32_t *ebx,
2017 uint32_t *ecx, uint32_t *edx)
2018{
2019 /* test if maximum index reached */
2020 if (index & 0x80000000) {
2021 if (index > env->cpuid_xlevel)
2022 index = env->cpuid_level;
2023 } else {
2024 if (index > env->cpuid_level)
2025 index = env->cpuid_level;
2026 }
2027
2028 switch(index) {
2029 case 0:
2030 *eax = env->cpuid_level;
6d9fef1a 2031 get_cpuid_vendor(env, ebx, ecx, edx);
6fd805e1
AL		 2032 break;
2033 case 1:
2034 *eax = env->cpuid_version;
2035 *ebx = (env->cpuid_apic_id << 24) | 8 << 8; /* CLFLUSH size in quad words, Linux wants it. */
2036 *ecx = env->cpuid_ext_features;
2037 *edx = env->cpuid_features;
400281af
AP		 2038 if (env->nr_cores * env->nr_threads > 1) {
2039 *ebx |= (env->nr_cores * env->nr_threads) << 16;
2040 *edx |= 1 << 28; /* HTT bit */
2041 }
6fd805e1
AL		 2042 break;
2043 case 2:
2044 /* cache info: needed for Pentium Pro compatibility */
2045 *eax = 1;
2046 *ebx = 0;
2047 *ecx = 0;
2048 *edx = 0x2c307d;
2049 break;
2050 case 4:
2051 /* cache info: needed for Core compatibility */
400281af
AP		 2052 if (env->nr_cores > 1) {
2053 *eax = (env->nr_cores - 1) << 26;
2054 } else {
2055 *eax = 0;
2056 }
e00b6f80 2057 switch (count) {
6fd805e1 2058 case 0: /* L1 dcache info */
400281af 2059 *eax |= 0x0000121;
6fd805e1
AL		 2060 *ebx = 0x1c0003f;
2061 *ecx = 0x000003f;
2062 *edx = 0x0000001;
2063 break;
2064 case 1: /* L1 icache info */
400281af 2065 *eax |= 0x0000122;
6fd805e1
AL		 2066 *ebx = 0x1c0003f;
2067 *ecx = 0x000003f;
2068 *edx = 0x0000001;
2069 break;
2070 case 2: /* L2 cache info */
400281af
AP		 2071 *eax |= 0x0000143;
2072 if (env->nr_threads > 1) {
2073 *eax |= (env->nr_threads - 1) << 14;
2074 }
6fd805e1
AL		 2075 *ebx = 0x3c0003f;
2076 *ecx = 0x0000fff;
2077 *edx = 0x0000001;
2078 break;
2079 default: /* end of info */
2080 *eax = 0;
2081 *ebx = 0;
2082 *ecx = 0;
2083 *edx = 0;
2084 break;
2085 }
6fd805e1
AL		 2086 break;
2087 case 5:
2088 /* mwait info: needed for Core compatibility */
2089 *eax = 0; /* Smallest monitor-line size in bytes */
2090 *ebx = 0; /* Largest monitor-line size in bytes */
2091 *ecx = CPUID_MWAIT_EMX | CPUID_MWAIT_IBE;
2092 *edx = 0;
2093 break;
2094 case 6:
2095 /* Thermal and Power Leaf */
2096 *eax = 0;
2097 *ebx = 0;
2098 *ecx = 0;
2099 *edx = 0;
2100 break;
2101 case 9:
2102 /* Direct Cache Access Information Leaf */
2103 *eax = 0; /* Bits 0-31 in DCA_CAP MSR */
2104 *ebx = 0;
2105 *ecx = 0;
2106 *edx = 0;
2107 break;
2108 case 0xA:
2109 /* Architectural Performance Monitoring Leaf */
2110 *eax = 0;
2111 *ebx = 0;
2112 *ecx = 0;
2113 *edx = 0;
2114 break;
2115 case 0x80000000:
2116 *eax = env->cpuid_xlevel;
2117 *ebx = env->cpuid_vendor1;
2118 *edx = env->cpuid_vendor2;
2119 *ecx = env->cpuid_vendor3;
2120 break;
2121 case 0x80000001:
f441bee8 2122 *eax = env->cpuid_version;
6fd805e1
AL		 2123 *ebx = 0;
2124 *ecx = env->cpuid_ext3_features;
2125 *edx = env->cpuid_ext2_features;
7ba1e619 2126
6d9fef1a
AP		 2127 /* The Linux kernel checks for the CMPLegacy bit and
2128 * discards multiple thread information if it is set.
2129 * So dont set it here for Intel to make Linux guests happy.
2130 */
2131 if (env->nr_cores * env->nr_threads > 1) {
2132 uint32_t tebx, tecx, tedx;
2133 get_cpuid_vendor(env, &tebx, &tecx, &tedx);
2134 if (tebx != CPUID_VENDOR_INTEL_1 ||
2135 tedx != CPUID_VENDOR_INTEL_2 ||
2136 tecx != CPUID_VENDOR_INTEL_3) {
2137 *ecx |= 1 << 1; /* CmpLegacy bit */
2138 }
400281af
AP		 2139 }
2140
7ba1e619 2141 if (kvm_enabled()) {
f1e00a9c 2142 /* Nested SVM not yet supported in upstream QEMU */
671e4676 2143 *ecx &= ~CPUID_EXT3_SVM;
7ba1e619 2144 }
6fd805e1
AL		 2145 break;
2146 case 0x80000002:
2147 case 0x80000003:
2148 case 0x80000004:
2149 *eax = env->cpuid_model[(index - 0x80000002) * 4 + 0];
2150 *ebx = env->cpuid_model[(index - 0x80000002) * 4 + 1];
2151 *ecx = env->cpuid_model[(index - 0x80000002) * 4 + 2];
2152 *edx = env->cpuid_model[(index - 0x80000002) * 4 + 3];
2153 break;
2154 case 0x80000005:
2155 /* cache info (L1 cache) */
2156 *eax = 0x01ff01ff;
2157 *ebx = 0x01ff01ff;
2158 *ecx = 0x40020140;
2159 *edx = 0x40020140;
2160 break;
2161 case 0x80000006:
2162 /* cache info (L2 cache) */
2163 *eax = 0;
2164 *ebx = 0x42004200;
2165 *ecx = 0x02008140;
2166 *edx = 0;
2167 break;
2168 case 0x80000008:
2169 /* virtual & phys address size in low 2 bytes. */
2170/* XXX: This value must match the one used in the MMU code. */
2171 if (env->cpuid_ext2_features & CPUID_EXT2_LM) {
2172 /* 64 bit processor */
6fd805e1
AL		 2173/* XXX: The physical address space is limited to 42 bits in exec.c. */
2174 *eax = 0x00003028; /* 48 bits virtual, 40 bits physical */
6fd805e1 2175 } else {
6fd805e1
AL		 2176 if (env->cpuid_features & CPUID_PSE36)
2177 *eax = 0x00000024; /* 36 bits physical */
2178 else
2179 *eax = 0x00000020; /* 32 bits physical */
6fd805e1
AL		 2180 }
2181 *ebx = 0;
2182 *ecx = 0;
2183 *edx = 0;
400281af
AP		 2184 if (env->nr_cores * env->nr_threads > 1) {
2185 *ecx |= (env->nr_cores * env->nr_threads) - 1;
2186 }
6fd805e1
AL		 2187 break;
2188 case 0x8000000A:
2189 *eax = 0x00000001; /* SVM Revision */
2190 *ebx = 0x00000010; /* nr of ASIDs */
2191 *ecx = 0;
2192 *edx = 0; /* optional features */
2193 break;
2194 default:
2195 /* reserved values: zero */
2196 *eax = 0;
2197 *ebx = 0;
2198 *ecx = 0;
2199 *edx = 0;
2200 break;
2201 }
2202}
01df040b 2203
84273177
JK		 2204
2205int cpu_x86_get_descr_debug(CPUX86State *env, unsigned int selector,
2206 target_ulong *base, unsigned int *limit,
2207 unsigned int *flags)
2208{
2209 SegmentCache *dt;
2210 target_ulong ptr;
2211 uint32_t e1, e2;
2212 int index;
2213
2214 if (selector & 0x4)
2215 dt = &env->ldt;
2216 else
2217 dt = &env->gdt;
2218 index = selector & ~7;
2219 ptr = dt->base + index;
2220 if ((index + 7) > dt->limit
2221 || cpu_memory_rw_debug(env, ptr, (uint8_t *)&e1, sizeof(e1), 0) != 0
2222 || cpu_memory_rw_debug(env, ptr+4, (uint8_t *)&e2, sizeof(e2), 0) != 0)
2223 return 0;
2224
2225 *base = ((e1 >> 16) | ((e2 & 0xff) << 16) | (e2 & 0xff000000));
2226 *limit = (e1 & 0xffff) | (e2 & 0x000f0000);
2227 if (e2 & DESC_G_MASK)
2228 *limit = (*limit << 12) | 0xfff;
2229 *flags = e2;
2230
2231 return 1;
2232}
2233
01df040b
AL		 2234CPUX86State *cpu_x86_init(const char *cpu_model)
2235{
2236 CPUX86State *env;
2237 static int inited;
2238
2239 env = qemu_mallocz(sizeof(CPUX86State));
01df040b
AL		 2240 cpu_exec_init(env);
2241 env->cpu_model_str = cpu_model;
2242
2243 /* init various static tables */
2244 if (!inited) {
2245 inited = 1;
2246 optimize_flags_init();
2247#ifndef CONFIG_USER_ONLY
2248 prev_debug_excp_handler =
2249 cpu_set_debug_excp_handler(breakpoint_handler);
2250#endif
2251 }
2252 if (cpu_x86_register(env, cpu_model) < 0) {
2253 cpu_x86_close(env);
2254 return NULL;
2255 }
79c4f6b0 2256 mce_init(env);
0bf46a40
AL		 2257
2258 qemu_init_vcpu(env);
2259
01df040b
AL		 2260 return env;
2261}
b09ea7d5
GN		 2262
2263#if !defined(CONFIG_USER_ONLY)
2264void do_cpu_init(CPUState *env)
2265{
2266 int sipi = env->interrupt_request & CPU_INTERRUPT_SIPI;
2267 cpu_reset(env);
2268 env->interrupt_request = sipi;
2269 apic_init_reset(env);
2270}
2271
2272void do_cpu_sipi(CPUState *env)
2273{
2274 apic_sipi(env);
2275}
2276#else
2277void do_cpu_init(CPUState *env)
2278{
2279}
2280void do_cpu_sipi(CPUState *env)
2281{
2282}
2283#endif
Empty description
This page took 0.804226 seconds and 4 git commands to generate.