target-i386/cpu.c

   1 /*
   2  *  i386 CPUID helper functions
   3  *
   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
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <inttypes.h>
  23
  24 #include "cpu.h"
  25 #include "kvm.h"
  26
  27 #include "qemu-option.h"
  28 #include "qemu-config.h"
  29
  30 #include "qapi/qapi-visit-core.h"
  31
  32 #include "hyperv.h"
  33
  34 /* feature flags taken from "Intel Processor Identification and the CPUID
  35  * Instruction" and AMD's "CPUID Specification".  In cases of disagreement
  36  * between feature naming conventions, aliases may be added.
  37  */
  38 static const char *feature_name[] = {
  39     "fpu", "vme", "de", "pse",
  40     "tsc", "msr", "pae", "mce",
  41     "cx8", "apic", NULL, "sep",
  42     "mtrr", "pge", "mca", "cmov",
  43     "pat", "pse36", "pn" /* Intel psn */, "clflush" /* Intel clfsh */,
  44     NULL, "ds" /* Intel dts */, "acpi", "mmx",
  45     "fxsr", "sse", "sse2", "ss",
  46     "ht" /* Intel htt */, "tm", "ia64", "pbe",
  47 };
  48 static const char *ext_feature_name[] = {
  49     "pni|sse3" /* Intel,AMD sse3 */, "pclmulqdq|pclmuldq", "dtes64", "monitor",
  50     "ds_cpl", "vmx", "smx", "est",
  51     "tm2", "ssse3", "cid", NULL,
  52     "fma", "cx16", "xtpr", "pdcm",
  53     NULL, NULL, "dca", "sse4.1|sse4_1",
  54     "sse4.2|sse4_2", "x2apic", "movbe", "popcnt",
  55     "tsc-deadline", "aes", "xsave", "osxsave",
  56     "avx", NULL, NULL, "hypervisor",
  57 };
  58 static const char *ext2_feature_name[] = {
  59     "fpu", "vme", "de", "pse",
  60     "tsc", "msr", "pae", "mce",
  61     "cx8" /* AMD CMPXCHG8B */, "apic", NULL, "syscall",
  62     "mtrr", "pge", "mca", "cmov",
  63     "pat", "pse36", NULL, NULL /* Linux mp */,
  64     "nx|xd", NULL, "mmxext", "mmx",
  65     "fxsr", "fxsr_opt|ffxsr", "pdpe1gb" /* AMD Page1GB */, "rdtscp",
  66     NULL, "lm|i64", "3dnowext", "3dnow",
  67 };
  68 static const char *ext3_feature_name[] = {
  69     "lahf_lm" /* AMD LahfSahf */, "cmp_legacy", "svm", "extapic" /* AMD ExtApicSpace */,
  70     "cr8legacy" /* AMD AltMovCr8 */, "abm", "sse4a", "misalignsse",
  71     "3dnowprefetch", "osvw", "ibs", "xop",
  72     "skinit", "wdt", NULL, NULL,
  73     "fma4", NULL, "cvt16", "nodeid_msr",
  74     NULL, NULL, NULL, NULL,
  75     NULL, NULL, NULL, NULL,
  76     NULL, NULL, NULL, NULL,
  77 };
  78
  79 static const char *kvm_feature_name[] = {
  80     "kvmclock", "kvm_nopiodelay", "kvm_mmu", "kvmclock", "kvm_asyncpf", NULL, NULL, NULL,
  81     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  82     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  83     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  84 };
  85
  86 static const char *svm_feature_name[] = {
  87     "npt", "lbrv", "svm_lock", "nrip_save",
  88     "tsc_scale", "vmcb_clean",  "flushbyasid", "decodeassists",
  89     NULL, NULL, "pause_filter", NULL,
  90     "pfthreshold", NULL, NULL, NULL,
  91     NULL, NULL, NULL, NULL,
  92     NULL, NULL, NULL, NULL,
  93     NULL, NULL, NULL, NULL,
  94     NULL, NULL, NULL, NULL,
  95 };
  96
  97 /* collects per-function cpuid data
  98  */
  99 typedef struct model_features_t {
 100     uint32_t *guest_feat;
 101     uint32_t *host_feat;
 102     uint32_t check_feat;
 103     const char **flag_names;
 104     uint32_t cpuid;
 105     } model_features_t;
 106
 107 int check_cpuid = 0;
 108 int enforce_cpuid = 0;
 109
 110 void host_cpuid(uint32_t function, uint32_t count,
 111                 uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx)
 112 {
 113 #if defined(CONFIG_KVM)
 114     uint32_t vec[4];
 115
 116 #ifdef __x86_64__
 117     asm volatile("cpuid"
 118                  : "=a"(vec[0]), "=b"(vec[1]),
 119                    "=c"(vec[2]), "=d"(vec[3])
 120                  : "0"(function), "c"(count) : "cc");
 121 #else
 122     asm volatile("pusha \n\t"
 123                  "cpuid \n\t"
 124                  "mov %%eax, 0(%2) \n\t"
 125                  "mov %%ebx, 4(%2) \n\t"
 126                  "mov %%ecx, 8(%2) \n\t"
 127                  "mov %%edx, 12(%2) \n\t"
 128                  "popa"
 129                  : : "a"(function), "c"(count), "S"(vec)
 130                  : "memory", "cc");
 131 #endif
 132
 133     if (eax)
 134         *eax = vec[0];
 135     if (ebx)
 136         *ebx = vec[1];
 137     if (ecx)
 138         *ecx = vec[2];
 139     if (edx)
 140         *edx = vec[3];
 141 #endif
 142 }
 143
 144 #define iswhite(c) ((c) && ((c) <= ' ' || '~' < (c)))
 145
 146 /* general substring compare of *[s1..e1) and *[s2..e2).  sx is start of
 147  * a substring.  ex if !NULL points to the first char after a substring,
 148  * otherwise the string is assumed to sized by a terminating nul.
 149  * Return lexical ordering of *s1:*s2.
 150  */
 151 static int sstrcmp(const char *s1, const char *e1, const char *s2,
 152     const char *e2)
 153 {
 154     for (;;) {
 155         if (!*s1 || !*s2 || *s1 != *s2)
 156             return (*s1 - *s2);
 157         ++s1, ++s2;
 158         if (s1 == e1 && s2 == e2)
 159             return (0);
 160         else if (s1 == e1)
 161             return (*s2);
 162         else if (s2 == e2)
 163             return (*s1);
 164     }
 165 }
 166
 167 /* compare *[s..e) to *altstr.  *altstr may be a simple string or multiple
 168  * '|' delimited (possibly empty) strings in which case search for a match
 169  * within the alternatives proceeds left to right.  Return 0 for success,
 170  * non-zero otherwise.
 171  */
 172 static int altcmp(const char *s, const char *e, const char *altstr)
 173 {
 174     const char *p, *q;
 175
 176     for (q = p = altstr; ; ) {
 177         while (*p && *p != '|')
 178             ++p;
 179         if ((q == p && !*s) || (q != p && !sstrcmp(s, e, q, p)))
 180             return (0);
 181         if (!*p)
 182             return (1);
 183         else
 184             q = ++p;
 185     }
 186 }
 187
 188 /* search featureset for flag *[s..e), if found set corresponding bit in
 189  * *pval and return true, otherwise return false
 190  */
 191 static bool lookup_feature(uint32_t *pval, const char *s, const char *e,
 192                            const char **featureset)
 193 {
 194     uint32_t mask;
 195     const char **ppc;
 196     bool found = false;
 197
 198     for (mask = 1, ppc = featureset; mask; mask <<= 1, ++ppc) {
 199         if (*ppc && !altcmp(s, e, *ppc)) {
 200             *pval |= mask;
 201             found = true;
 202         }
 203     }
 204     return found;
 205 }
 206
 207 static void add_flagname_to_bitmaps(const char *flagname, uint32_t *features,
 208                                     uint32_t *ext_features,
 209                                     uint32_t *ext2_features,
 210                                     uint32_t *ext3_features,
 211                                     uint32_t *kvm_features,
 212                                     uint32_t *svm_features)
 213 {
 214     if (!lookup_feature(features, flagname, NULL, feature_name) &&
 215         !lookup_feature(ext_features, flagname, NULL, ext_feature_name) &&
 216         !lookup_feature(ext2_features, flagname, NULL, ext2_feature_name) &&
 217         !lookup_feature(ext3_features, flagname, NULL, ext3_feature_name) &&
 218         !lookup_feature(kvm_features, flagname, NULL, kvm_feature_name) &&
 219         !lookup_feature(svm_features, flagname, NULL, svm_feature_name))
 220             fprintf(stderr, "CPU feature %s not found\n", flagname);
 221 }
 222
 223 typedef struct x86_def_t {
 224     struct x86_def_t *next;
 225     const char *name;
 226     uint32_t level;
 227     uint32_t vendor1, vendor2, vendor3;
 228     int family;
 229     int model;
 230     int stepping;
 231     int tsc_khz;
 232     uint32_t features, ext_features, ext2_features, ext3_features;
 233     uint32_t kvm_features, svm_features;
 234     uint32_t xlevel;
 235     char model_id[48];
 236     int vendor_override;
 237     uint32_t flags;
 238     /* Store the results of Centaur's CPUID instructions */
 239     uint32_t ext4_features;
 240     uint32_t xlevel2;
 241     /* The feature bits on CPUID[EAX=7,ECX=0].EBX */
 242     uint32_t cpuid_7_0_ebx_features;
 243 } x86_def_t;
 244
 245 #define I486_FEATURES (CPUID_FP87 | CPUID_VME | CPUID_PSE)
 246 #define PENTIUM_FEATURES (I486_FEATURES | CPUID_DE | CPUID_TSC | \
 247           CPUID_MSR | CPUID_MCE | CPUID_CX8 | CPUID_MMX | CPUID_APIC)
 248 #define PENTIUM2_FEATURES (PENTIUM_FEATURES | CPUID_PAE | CPUID_SEP | \
 249           CPUID_MTRR | CPUID_PGE | CPUID_MCA | CPUID_CMOV | CPUID_PAT | \
 250           CPUID_PSE36 | CPUID_FXSR)
 251 #define PENTIUM3_FEATURES (PENTIUM2_FEATURES | CPUID_SSE)
 252 #define PPRO_FEATURES (CPUID_FP87 | CPUID_DE | CPUID_PSE | CPUID_TSC | \
 253           CPUID_MSR | CPUID_MCE | CPUID_CX8 | CPUID_PGE | CPUID_CMOV | \
 254           CPUID_PAT | CPUID_FXSR | CPUID_MMX | CPUID_SSE | CPUID_SSE2 | \
 255           CPUID_PAE | CPUID_SEP | CPUID_APIC)
 256 #define EXT2_FEATURE_MASK 0x0183F3FF
 257
 258 #define TCG_FEATURES (CPUID_FP87 | CPUID_PSE | CPUID_TSC | CPUID_MSR | \
 259           CPUID_PAE | CPUID_MCE | CPUID_CX8 | CPUID_APIC | CPUID_SEP | \
 260           CPUID_MTRR | CPUID_PGE | CPUID_MCA | CPUID_CMOV | CPUID_PAT | \
 261           CPUID_PSE36 | CPUID_CLFLUSH | CPUID_ACPI | CPUID_MMX | \
 262           CPUID_FXSR | CPUID_SSE | CPUID_SSE2 | CPUID_SS)
 263           /* partly implemented:
 264           CPUID_MTRR, CPUID_MCA, CPUID_CLFLUSH (needed for Win64)
 265           CPUID_PSE36 (needed for Solaris) */
 266           /* missing:
 267           CPUID_VME, CPUID_DTS, CPUID_SS, CPUID_HT, CPUID_TM, CPUID_PBE */
 268 #define TCG_EXT_FEATURES (CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | \
 269           CPUID_EXT_CX16 | CPUID_EXT_POPCNT | \
 270           CPUID_EXT_HYPERVISOR)
 271           /* missing:
 272           CPUID_EXT_DTES64, CPUID_EXT_DSCPL, CPUID_EXT_VMX, CPUID_EXT_EST,
 273           CPUID_EXT_TM2, CPUID_EXT_XTPR, CPUID_EXT_PDCM, CPUID_EXT_XSAVE */
 274 #define TCG_EXT2_FEATURES ((TCG_FEATURES & EXT2_FEATURE_MASK) | \
 275           CPUID_EXT2_NX | CPUID_EXT2_MMXEXT | CPUID_EXT2_RDTSCP | \
 276           CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT)
 277           /* missing:
 278           CPUID_EXT2_PDPE1GB */
 279 #define TCG_EXT3_FEATURES (CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM | \
 280           CPUID_EXT3_CR8LEG | CPUID_EXT3_ABM | CPUID_EXT3_SSE4A)
 281 #define TCG_SVM_FEATURES 0
 282
 283 /* maintains list of cpu model definitions
 284  */
 285 static x86_def_t *x86_defs = {NULL};
 286
 287 /* built-in cpu model definitions (deprecated)
 288  */
 289 static x86_def_t builtin_x86_defs[] = {
 290     {
 291         .name = "qemu64",
 292         .level = 4,
 293         .vendor1 = CPUID_VENDOR_AMD_1,
 294         .vendor2 = CPUID_VENDOR_AMD_2,
 295         .vendor3 = CPUID_VENDOR_AMD_3,
 296         .family = 6,
 297         .model = 2,
 298         .stepping = 3,
 299         .features = PPRO_FEATURES |
 300             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
 301             CPUID_PSE36,
 302         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_CX16 | CPUID_EXT_POPCNT,
 303         .ext2_features = (PPRO_FEATURES & EXT2_FEATURE_MASK) |
 304             CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
 305         .ext3_features = CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM |
 306             CPUID_EXT3_ABM | CPUID_EXT3_SSE4A,
 307         .xlevel = 0x8000000A,
 308         .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
 309     },
 310     {
 311         .name = "phenom",
 312         .level = 5,
 313         .vendor1 = CPUID_VENDOR_AMD_1,
 314         .vendor2 = CPUID_VENDOR_AMD_2,
 315         .vendor3 = CPUID_VENDOR_AMD_3,
 316         .family = 16,
 317         .model = 2,
 318         .stepping = 3,
 319         .features = PPRO_FEATURES |
 320             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
 321             CPUID_PSE36 | CPUID_VME | CPUID_HT,
 322         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_CX16 |
 323             CPUID_EXT_POPCNT,
 324         .ext2_features = (PPRO_FEATURES & EXT2_FEATURE_MASK) |
 325             CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX |
 326             CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT | CPUID_EXT2_MMXEXT |
 327             CPUID_EXT2_FFXSR | CPUID_EXT2_PDPE1GB | CPUID_EXT2_RDTSCP,
 328         /* Missing: CPUID_EXT3_CMP_LEG, CPUID_EXT3_EXTAPIC,
 329                     CPUID_EXT3_CR8LEG,
 330                     CPUID_EXT3_MISALIGNSSE, CPUID_EXT3_3DNOWPREFETCH,
 331                     CPUID_EXT3_OSVW, CPUID_EXT3_IBS */
 332         .ext3_features = CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM |
 333             CPUID_EXT3_ABM | CPUID_EXT3_SSE4A,
 334         .svm_features = CPUID_SVM_NPT | CPUID_SVM_LBRV,
 335         .xlevel = 0x8000001A,
 336         .model_id = "AMD Phenom(tm) 9550 Quad-Core Processor"
 337     },
 338     {
 339         .name = "core2duo",
 340         .level = 10,
 341         .family = 6,
 342         .model = 15,
 343         .stepping = 11,
 344         .features = PPRO_FEATURES |
 345             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
 346             CPUID_PSE36 | CPUID_VME | CPUID_DTS | CPUID_ACPI | CPUID_SS |
 347             CPUID_HT | CPUID_TM | CPUID_PBE,
 348         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_SSSE3 |
 349             CPUID_EXT_DTES64 | CPUID_EXT_DSCPL | CPUID_EXT_VMX | CPUID_EXT_EST |
 350             CPUID_EXT_TM2 | CPUID_EXT_CX16 | CPUID_EXT_XTPR | CPUID_EXT_PDCM,
 351         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
 352         .ext3_features = CPUID_EXT3_LAHF_LM,
 353         .xlevel = 0x80000008,
 354         .model_id = "Intel(R) Core(TM)2 Duo CPU     T7700  @ 2.40GHz",
 355     },
 356     {
 357         .name = "kvm64",
 358         .level = 5,
 359         .vendor1 = CPUID_VENDOR_INTEL_1,
 360         .vendor2 = CPUID_VENDOR_INTEL_2,
 361         .vendor3 = CPUID_VENDOR_INTEL_3,
 362         .family = 15,
 363         .model = 6,
 364         .stepping = 1,
 365         /* Missing: CPUID_VME, CPUID_HT */
 366         .features = PPRO_FEATURES |
 367             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
 368             CPUID_PSE36,
 369         /* Missing: CPUID_EXT_POPCNT, CPUID_EXT_MONITOR */
 370         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_CX16,
 371         /* Missing: CPUID_EXT2_PDPE1GB, CPUID_EXT2_RDTSCP */
 372         .ext2_features = (PPRO_FEATURES & EXT2_FEATURE_MASK) |
 373             CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
 374         /* Missing: CPUID_EXT3_LAHF_LM, CPUID_EXT3_CMP_LEG, CPUID_EXT3_EXTAPIC,
 375                     CPUID_EXT3_CR8LEG, CPUID_EXT3_ABM, CPUID_EXT3_SSE4A,
 376                     CPUID_EXT3_MISALIGNSSE, CPUID_EXT3_3DNOWPREFETCH,
 377                     CPUID_EXT3_OSVW, CPUID_EXT3_IBS, CPUID_EXT3_SVM */
 378         .ext3_features = 0,
 379         .xlevel = 0x80000008,
 380         .model_id = "Common KVM processor"
 381     },
 382     {
 383         .name = "qemu32",
 384         .level = 4,
 385         .family = 6,
 386         .model = 3,
 387         .stepping = 3,
 388         .features = PPRO_FEATURES,
 389         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_POPCNT,
 390         .xlevel = 0x80000004,
 391         .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
 392     },
 393     {
 394         .name = "kvm32",
 395         .level = 5,
 396         .family = 15,
 397         .model = 6,
 398         .stepping = 1,
 399         .features = PPRO_FEATURES |
 400             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | CPUID_PSE36,
 401         .ext_features = CPUID_EXT_SSE3,
 402         .ext2_features = PPRO_FEATURES & EXT2_FEATURE_MASK,
 403         .ext3_features = 0,
 404         .xlevel = 0x80000008,
 405         .model_id = "Common 32-bit KVM processor"
 406     },
 407     {
 408         .name = "coreduo",
 409         .level = 10,
 410         .family = 6,
 411         .model = 14,
 412         .stepping = 8,
 413         .features = PPRO_FEATURES | CPUID_VME |
 414             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | CPUID_DTS | CPUID_ACPI |
 415             CPUID_SS | CPUID_HT | CPUID_TM | CPUID_PBE,
 416         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_VMX |
 417             CPUID_EXT_EST | CPUID_EXT_TM2 | CPUID_EXT_XTPR | CPUID_EXT_PDCM,
 418         .ext2_features = CPUID_EXT2_NX,
 419         .xlevel = 0x80000008,
 420         .model_id = "Genuine Intel(R) CPU           T2600  @ 2.16GHz",
 421     },
 422     {
 423         .name = "486",
 424         .level = 1,
 425         .family = 4,
 426         .model = 0,
 427         .stepping = 0,
 428         .features = I486_FEATURES,
 429         .xlevel = 0,
 430     },
 431     {
 432         .name = "pentium",
 433         .level = 1,
 434         .family = 5,
 435         .model = 4,
 436         .stepping = 3,
 437         .features = PENTIUM_FEATURES,
 438         .xlevel = 0,
 439     },
 440     {
 441         .name = "pentium2",
 442         .level = 2,
 443         .family = 6,
 444         .model = 5,
 445         .stepping = 2,
 446         .features = PENTIUM2_FEATURES,
 447         .xlevel = 0,
 448     },
 449     {
 450         .name = "pentium3",
 451         .level = 2,
 452         .family = 6,
 453         .model = 7,
 454         .stepping = 3,
 455         .features = PENTIUM3_FEATURES,
 456         .xlevel = 0,
 457     },
 458     {
 459         .name = "athlon",
 460         .level = 2,
 461         .vendor1 = CPUID_VENDOR_AMD_1,
 462         .vendor2 = CPUID_VENDOR_AMD_2,
 463         .vendor3 = CPUID_VENDOR_AMD_3,
 464         .family = 6,
 465         .model = 2,
 466         .stepping = 3,
 467         .features = PPRO_FEATURES | CPUID_PSE36 | CPUID_VME | CPUID_MTRR | CPUID_MCA,
 468         .ext2_features = (PPRO_FEATURES & EXT2_FEATURE_MASK) | CPUID_EXT2_MMXEXT | CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT,
 469         .xlevel = 0x80000008,
 470         /* XXX: put another string ? */
 471         .model_id = "QEMU Virtual CPU version " QEMU_VERSION,
 472     },
 473     {
 474         .name = "n270",
 475         /* original is on level 10 */
 476         .level = 5,
 477         .family = 6,
 478         .model = 28,
 479         .stepping = 2,
 480         .features = PPRO_FEATURES |
 481             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | CPUID_VME | CPUID_DTS |
 482             CPUID_ACPI | CPUID_SS | CPUID_HT | CPUID_TM | CPUID_PBE,
 483             /* Some CPUs got no CPUID_SEP */
 484         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_SSSE3 |
 485             CPUID_EXT_DSCPL | CPUID_EXT_EST | CPUID_EXT_TM2 | CPUID_EXT_XTPR,
 486         .ext2_features = (PPRO_FEATURES & EXT2_FEATURE_MASK) | CPUID_EXT2_NX,
 487         .ext3_features = CPUID_EXT3_LAHF_LM,
 488         .xlevel = 0x8000000A,
 489         .model_id = "Intel(R) Atom(TM) CPU N270   @ 1.60GHz",
 490     },
 491 };
 492
 493 static int cpu_x86_fill_model_id(char *str)
 494 {
 495     uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
 496     int i;
 497
 498     for (i = 0; i < 3; i++) {
 499         host_cpuid(0x80000002 + i, 0, &eax, &ebx, &ecx, &edx);
 500         memcpy(str + i * 16 +  0, &eax, 4);
 501         memcpy(str + i * 16 +  4, &ebx, 4);
 502         memcpy(str + i * 16 +  8, &ecx, 4);
 503         memcpy(str + i * 16 + 12, &edx, 4);
 504     }
 505     return 0;
 506 }
 507
 508 static int cpu_x86_fill_host(x86_def_t *x86_cpu_def)
 509 {
 510     uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
 511
 512     x86_cpu_def->name = "host";
 513     host_cpuid(0x0, 0, &eax, &ebx, &ecx, &edx);
 514     x86_cpu_def->level = eax;
 515     x86_cpu_def->vendor1 = ebx;
 516     x86_cpu_def->vendor2 = edx;
 517     x86_cpu_def->vendor3 = ecx;
 518
 519     host_cpuid(0x1, 0, &eax, &ebx, &ecx, &edx);
 520     x86_cpu_def->family = ((eax >> 8) & 0x0F) + ((eax >> 20) & 0xFF);
 521     x86_cpu_def->model = ((eax >> 4) & 0x0F) | ((eax & 0xF0000) >> 12);
 522     x86_cpu_def->stepping = eax & 0x0F;
 523     x86_cpu_def->ext_features = ecx;
 524     x86_cpu_def->features = edx;
 525
 526     if (kvm_enabled() && x86_cpu_def->level >= 7) {
 527         x86_cpu_def->cpuid_7_0_ebx_features = kvm_arch_get_supported_cpuid(kvm_state, 0x7, 0, R_EBX);
 528     } else {
 529         x86_cpu_def->cpuid_7_0_ebx_features = 0;
 530     }
 531
 532     host_cpuid(0x80000000, 0, &eax, &ebx, &ecx, &edx);
 533     x86_cpu_def->xlevel = eax;
 534
 535     host_cpuid(0x80000001, 0, &eax, &ebx, &ecx, &edx);
 536     x86_cpu_def->ext2_features = edx;
 537     x86_cpu_def->ext3_features = ecx;
 538     cpu_x86_fill_model_id(x86_cpu_def->model_id);
 539     x86_cpu_def->vendor_override = 0;
 540
 541     /* Call Centaur's CPUID instruction. */
 542     if (x86_cpu_def->vendor1 == CPUID_VENDOR_VIA_1 &&
 543         x86_cpu_def->vendor2 == CPUID_VENDOR_VIA_2 &&
 544         x86_cpu_def->vendor3 == CPUID_VENDOR_VIA_3) {
 545         host_cpuid(0xC0000000, 0, &eax, &ebx, &ecx, &edx);
 546         if (eax >= 0xC0000001) {
 547             /* Support VIA max extended level */
 548             x86_cpu_def->xlevel2 = eax;
 549             host_cpuid(0xC0000001, 0, &eax, &ebx, &ecx, &edx);
 550             x86_cpu_def->ext4_features = edx;
 551         }
 552     }
 553
 554     /*
 555      * Every SVM feature requires emulation support in KVM - so we can't just
 556      * read the host features here. KVM might even support SVM features not
 557      * available on the host hardware. Just set all bits and mask out the
 558      * unsupported ones later.
 559      */
 560     x86_cpu_def->svm_features = -1;
 561
 562     return 0;
 563 }
 564
 565 static int unavailable_host_feature(struct model_features_t *f, uint32_t mask)
 566 {
 567     int i;
 568
 569     for (i = 0; i < 32; ++i)
 570         if (1 << i & mask) {
 571             fprintf(stderr, "warning: host cpuid %04x_%04x lacks requested"
 572                 " flag '%s' [0x%08x]\n",
 573                 f->cpuid >> 16, f->cpuid & 0xffff,
 574                 f->flag_names[i] ? f->flag_names[i] : "[reserved]", mask);
 575             break;
 576         }
 577     return 0;
 578 }
 579
 580 /* best effort attempt to inform user requested cpu flags aren't making
 581  * their way to the guest.  Note: ft[].check_feat ideally should be
 582  * specified via a guest_def field to suppress report of extraneous flags.
 583  */
 584 static int check_features_against_host(x86_def_t *guest_def)
 585 {
 586     x86_def_t host_def;
 587     uint32_t mask;
 588     int rv, i;
 589     struct model_features_t ft[] = {
 590         {&guest_def->features, &host_def.features,
 591             ~0, feature_name, 0x00000000},
 592         {&guest_def->ext_features, &host_def.ext_features,
 593             ~CPUID_EXT_HYPERVISOR, ext_feature_name, 0x00000001},
 594         {&guest_def->ext2_features, &host_def.ext2_features,
 595             ~PPRO_FEATURES, ext2_feature_name, 0x80000000},
 596         {&guest_def->ext3_features, &host_def.ext3_features,
 597             ~CPUID_EXT3_SVM, ext3_feature_name, 0x80000001}};
 598
 599     cpu_x86_fill_host(&host_def);
 600     for (rv = 0, i = 0; i < ARRAY_SIZE(ft); ++i)
 601         for (mask = 1; mask; mask <<= 1)
 602             if (ft[i].check_feat & mask && *ft[i].guest_feat & mask &&
 603                 !(*ft[i].host_feat & mask)) {
 604                     unavailable_host_feature(&ft[i], mask);
 605                     rv = 1;
 606                 }
 607     return rv;
 608 }
 609
 610 static void x86_cpuid_version_get_family(Object *obj, Visitor *v, void *opaque,
 611                                          const char *name, Error **errp)
 612 {
 613     X86CPU *cpu = X86_CPU(obj);
 614     CPUX86State *env = &cpu->env;
 615     int64_t value;
 616
 617     value = (env->cpuid_version >> 8) & 0xf;
 618     if (value == 0xf) {
 619         value += (env->cpuid_version >> 20) & 0xff;
 620     }
 621     visit_type_int(v, &value, name, errp);
 622 }
 623
 624 static void x86_cpuid_version_set_family(Object *obj, Visitor *v, void *opaque,
 625                                          const char *name, Error **errp)
 626 {
 627     X86CPU *cpu = X86_CPU(obj);
 628     CPUX86State *env = &cpu->env;
 629     const int64_t min = 0;
 630     const int64_t max = 0xff + 0xf;
 631     int64_t value;
 632
 633     visit_type_int(v, &value, name, errp);
 634     if (error_is_set(errp)) {
 635         return;
 636     }
 637     if (value < min || value > max) {
 638         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
 639                   name ? name : "null", value, min, max);
 640         return;
 641     }
 642
 643     env->cpuid_version &= ~0xff00f00;
 644     if (value > 0x0f) {
 645         env->cpuid_version |= 0xf00 | ((value - 0x0f) << 20);
 646     } else {
 647         env->cpuid_version |= value << 8;
 648     }
 649 }
 650
 651 static void x86_cpuid_version_get_model(Object *obj, Visitor *v, void *opaque,
 652                                         const char *name, Error **errp)
 653 {
 654     X86CPU *cpu = X86_CPU(obj);
 655     CPUX86State *env = &cpu->env;
 656     int64_t value;
 657
 658     value = (env->cpuid_version >> 4) & 0xf;
 659     value |= ((env->cpuid_version >> 16) & 0xf) << 4;
 660     visit_type_int(v, &value, name, errp);
 661 }
 662
 663 static void x86_cpuid_version_set_model(Object *obj, Visitor *v, void *opaque,
 664                                         const char *name, Error **errp)
 665 {
 666     X86CPU *cpu = X86_CPU(obj);
 667     CPUX86State *env = &cpu->env;
 668     const int64_t min = 0;
 669     const int64_t max = 0xff;
 670     int64_t value;
 671
 672     visit_type_int(v, &value, name, errp);
 673     if (error_is_set(errp)) {
 674         return;
 675     }
 676     if (value < min || value > max) {
 677         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
 678                   name ? name : "null", value, min, max);
 679         return;
 680     }
 681
 682     env->cpuid_version &= ~0xf00f0;
 683     env->cpuid_version |= ((value & 0xf) << 4) | ((value >> 4) << 16);
 684 }
 685
 686 static void x86_cpuid_version_get_stepping(Object *obj, Visitor *v,
 687                                            void *opaque, const char *name,
 688                                            Error **errp)
 689 {
 690     X86CPU *cpu = X86_CPU(obj);
 691     CPUX86State *env = &cpu->env;
 692     int64_t value;
 693
 694     value = env->cpuid_version & 0xf;
 695     visit_type_int(v, &value, name, errp);
 696 }
 697
 698 static void x86_cpuid_version_set_stepping(Object *obj, Visitor *v,
 699                                            void *opaque, const char *name,
 700                                            Error **errp)
 701 {
 702     X86CPU *cpu = X86_CPU(obj);
 703     CPUX86State *env = &cpu->env;
 704     const int64_t min = 0;
 705     const int64_t max = 0xf;
 706     int64_t value;
 707
 708     visit_type_int(v, &value, name, errp);
 709     if (error_is_set(errp)) {
 710         return;
 711     }
 712     if (value < min || value > max) {
 713         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
 714                   name ? name : "null", value, min, max);
 715         return;
 716     }
 717
 718     env->cpuid_version &= ~0xf;
 719     env->cpuid_version |= value & 0xf;
 720 }
 721
 722 static void x86_cpuid_get_level(Object *obj, Visitor *v, void *opaque,
 723                                 const char *name, Error **errp)
 724 {
 725     X86CPU *cpu = X86_CPU(obj);
 726     int64_t value;
 727
 728     value = cpu->env.cpuid_level;
 729     /* TODO Use visit_type_uint32() once available */
 730     visit_type_int(v, &value, name, errp);
 731 }
 732
 733 static void x86_cpuid_set_level(Object *obj, Visitor *v, void *opaque,
 734                                 const char *name, Error **errp)
 735 {
 736     X86CPU *cpu = X86_CPU(obj);
 737     const int64_t min = 0;
 738     const int64_t max = UINT32_MAX;
 739     int64_t value;
 740
 741     /* TODO Use visit_type_uint32() once available */
 742     visit_type_int(v, &value, name, errp);
 743     if (error_is_set(errp)) {
 744         return;
 745     }
 746     if (value < min || value > max) {
 747         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
 748                   name ? name : "null", value, min, max);
 749         return;
 750     }
 751
 752     cpu->env.cpuid_level = value;
 753 }
 754
 755 static void x86_cpuid_get_xlevel(Object *obj, Visitor *v, void *opaque,
 756                                  const char *name, Error **errp)
 757 {
 758     X86CPU *cpu = X86_CPU(obj);
 759     int64_t value;
 760
 761     value = cpu->env.cpuid_xlevel;
 762     /* TODO Use visit_type_uint32() once available */
 763     visit_type_int(v, &value, name, errp);
 764 }
 765
 766 static void x86_cpuid_set_xlevel(Object *obj, Visitor *v, void *opaque,
 767                                  const char *name, Error **errp)
 768 {
 769     X86CPU *cpu = X86_CPU(obj);
 770     const int64_t min = 0;
 771     const int64_t max = UINT32_MAX;
 772     int64_t value;
 773
 774     /* TODO Use visit_type_uint32() once available */
 775     visit_type_int(v, &value, name, errp);
 776     if (error_is_set(errp)) {
 777         return;
 778     }
 779     if (value < min || value > max) {
 780         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
 781                   name ? name : "null", value, min, max);
 782         return;
 783     }
 784
 785     cpu->env.cpuid_xlevel = value;
 786 }
 787
 788 static char *x86_cpuid_get_vendor(Object *obj, Error **errp)
 789 {
 790     X86CPU *cpu = X86_CPU(obj);
 791     CPUX86State *env = &cpu->env;
 792     char *value;
 793     int i;
 794
 795     value = (char *)g_malloc(12 + 1);
 796     for (i = 0; i < 4; i++) {
 797         value[i    ] = env->cpuid_vendor1 >> (8 * i);
 798         value[i + 4] = env->cpuid_vendor2 >> (8 * i);
 799         value[i + 8] = env->cpuid_vendor3 >> (8 * i);
 800     }
 801     value[12] = '\0';
 802     return value;
 803 }
 804
 805 static void x86_cpuid_set_vendor(Object *obj, const char *value,
 806                                  Error **errp)
 807 {
 808     X86CPU *cpu = X86_CPU(obj);
 809     CPUX86State *env = &cpu->env;
 810     int i;
 811
 812     if (strlen(value) != 12) {
 813         error_set(errp, QERR_PROPERTY_VALUE_BAD, "",
 814                   "vendor", value);
 815         return;
 816     }
 817
 818     env->cpuid_vendor1 = 0;
 819     env->cpuid_vendor2 = 0;
 820     env->cpuid_vendor3 = 0;
 821     for (i = 0; i < 4; i++) {
 822         env->cpuid_vendor1 |= ((uint8_t)value[i    ]) << (8 * i);
 823         env->cpuid_vendor2 |= ((uint8_t)value[i + 4]) << (8 * i);
 824         env->cpuid_vendor3 |= ((uint8_t)value[i + 8]) << (8 * i);
 825     }
 826     env->cpuid_vendor_override = 1;
 827 }
 828
 829 static char *x86_cpuid_get_model_id(Object *obj, Error **errp)
 830 {
 831     X86CPU *cpu = X86_CPU(obj);
 832     CPUX86State *env = &cpu->env;
 833     char *value;
 834     int i;
 835
 836     value = g_malloc(48 + 1);
 837     for (i = 0; i < 48; i++) {
 838         value[i] = env->cpuid_model[i >> 2] >> (8 * (i & 3));
 839     }
 840     value[48] = '\0';
 841     return value;
 842 }
 843
 844 static void x86_cpuid_set_model_id(Object *obj, const char *model_id,
 845                                    Error **errp)
 846 {
 847     X86CPU *cpu = X86_CPU(obj);
 848     CPUX86State *env = &cpu->env;
 849     int c, len, i;
 850
 851     if (model_id == NULL) {
 852         model_id = "";
 853     }
 854     len = strlen(model_id);
 855     memset(env->cpuid_model, 0, 48);
 856     for (i = 0; i < 48; i++) {
 857         if (i >= len) {
 858             c = '\0';
 859         } else {
 860             c = (uint8_t)model_id[i];
 861         }
 862         env->cpuid_model[i >> 2] |= c << (8 * (i & 3));
 863     }
 864 }
 865
 866 static void x86_cpuid_get_tsc_freq(Object *obj, Visitor *v, void *opaque,
 867                                    const char *name, Error **errp)
 868 {
 869     X86CPU *cpu = X86_CPU(obj);
 870     int64_t value;
 871
 872     value = cpu->env.tsc_khz * 1000;
 873     visit_type_int(v, &value, name, errp);
 874 }
 875
 876 static void x86_cpuid_set_tsc_freq(Object *obj, Visitor *v, void *opaque,
 877                                    const char *name, Error **errp)
 878 {
 879     X86CPU *cpu = X86_CPU(obj);
 880     const int64_t min = 0;
 881     const int64_t max = INT_MAX;
 882     int64_t value;
 883
 884     visit_type_int(v, &value, name, errp);
 885     if (error_is_set(errp)) {
 886         return;
 887     }
 888     if (value < min || value > max) {
 889         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
 890                   name ? name : "null", value, min, max);
 891         return;
 892     }
 893
 894     cpu->env.tsc_khz = value / 1000;
 895 }
 896
 897 static int cpu_x86_find_by_name(x86_def_t *x86_cpu_def, const char *cpu_model)
 898 {
 899     unsigned int i;
 900     x86_def_t *def;
 901
 902     char *s = g_strdup(cpu_model);
 903     char *featurestr, *name = strtok(s, ",");
 904     /* Features to be added*/
 905     uint32_t plus_features = 0, plus_ext_features = 0;
 906     uint32_t plus_ext2_features = 0, plus_ext3_features = 0;
 907     uint32_t plus_kvm_features = 0, plus_svm_features = 0;
 908     /* Features to be removed */
 909     uint32_t minus_features = 0, minus_ext_features = 0;
 910     uint32_t minus_ext2_features = 0, minus_ext3_features = 0;
 911     uint32_t minus_kvm_features = 0, minus_svm_features = 0;
 912     uint32_t numvalue;
 913
 914     for (def = x86_defs; def; def = def->next)
 915         if (name && !strcmp(name, def->name))
 916             break;
 917     if (kvm_enabled() && name && strcmp(name, "host") == 0) {
 918         cpu_x86_fill_host(x86_cpu_def);
 919     } else if (!def) {
 920         goto error;
 921     } else {
 922         memcpy(x86_cpu_def, def, sizeof(*def));
 923     }
 924
 925     plus_kvm_features = ~0; /* not supported bits will be filtered out later */
 926
 927     add_flagname_to_bitmaps("hypervisor", &plus_features,
 928         &plus_ext_features, &plus_ext2_features, &plus_ext3_features,
 929         &plus_kvm_features, &plus_svm_features);
 930
 931     featurestr = strtok(NULL, ",");
 932
 933     while (featurestr) {
 934         char *val;
 935         if (featurestr[0] == '+') {
 936             add_flagname_to_bitmaps(featurestr + 1, &plus_features,
 937                             &plus_ext_features, &plus_ext2_features,
 938                             &plus_ext3_features, &plus_kvm_features,
 939                             &plus_svm_features);
 940         } else if (featurestr[0] == '-') {
 941             add_flagname_to_bitmaps(featurestr + 1, &minus_features,
 942                             &minus_ext_features, &minus_ext2_features,
 943                             &minus_ext3_features, &minus_kvm_features,
 944                             &minus_svm_features);
 945         } else if ((val = strchr(featurestr, '='))) {
 946             *val = 0; val++;
 947             if (!strcmp(featurestr, "family")) {
 948                 char *err;
 949                 numvalue = strtoul(val, &err, 0);
 950                 if (!*val || *err || numvalue > 0xff + 0xf) {
 951                     fprintf(stderr, "bad numerical value %s\n", val);
 952                     goto error;
 953                 }
 954                 x86_cpu_def->family = numvalue;
 955             } else if (!strcmp(featurestr, "model")) {
 956                 char *err;
 957                 numvalue = strtoul(val, &err, 0);
 958                 if (!*val || *err || numvalue > 0xff) {
 959                     fprintf(stderr, "bad numerical value %s\n", val);
 960                     goto error;
 961                 }
 962                 x86_cpu_def->model = numvalue;
 963             } else if (!strcmp(featurestr, "stepping")) {
 964                 char *err;
 965                 numvalue = strtoul(val, &err, 0);
 966                 if (!*val || *err || numvalue > 0xf) {
 967                     fprintf(stderr, "bad numerical value %s\n", val);
 968                     goto error;
 969                 }
 970                 x86_cpu_def->stepping = numvalue ;
 971             } else if (!strcmp(featurestr, "level")) {
 972                 char *err;
 973                 numvalue = strtoul(val, &err, 0);
 974                 if (!*val || *err) {
 975                     fprintf(stderr, "bad numerical value %s\n", val);
 976                     goto error;
 977                 }
 978                 x86_cpu_def->level = numvalue;
 979             } else if (!strcmp(featurestr, "xlevel")) {
 980                 char *err;
 981                 numvalue = strtoul(val, &err, 0);
 982                 if (!*val || *err) {
 983                     fprintf(stderr, "bad numerical value %s\n", val);
 984                     goto error;
 985                 }
 986                 if (numvalue < 0x80000000) {
 987                     numvalue += 0x80000000;
 988                 }
 989                 x86_cpu_def->xlevel = numvalue;
 990             } else if (!strcmp(featurestr, "vendor")) {
 991                 if (strlen(val) != 12) {
 992                     fprintf(stderr, "vendor string must be 12 chars long\n");
 993                     goto error;
 994                 }
 995                 x86_cpu_def->vendor1 = 0;
 996                 x86_cpu_def->vendor2 = 0;
 997                 x86_cpu_def->vendor3 = 0;
 998                 for(i = 0; i < 4; i++) {
 999                     x86_cpu_def->vendor1 |= ((uint8_t)val[i    ]) << (8 * i);
1000                     x86_cpu_def->vendor2 |= ((uint8_t)val[i + 4]) << (8 * i);
1001                     x86_cpu_def->vendor3 |= ((uint8_t)val[i + 8]) << (8 * i);
1002                 }
1003                 x86_cpu_def->vendor_override = 1;
1004             } else if (!strcmp(featurestr, "model_id")) {
1005                 pstrcpy(x86_cpu_def->model_id, sizeof(x86_cpu_def->model_id),
1006                         val);
1007             } else if (!strcmp(featurestr, "tsc_freq")) {
1008                 int64_t tsc_freq;
1009                 char *err;
1010
1011                 tsc_freq = strtosz_suffix_unit(val, &err,
1012                                                STRTOSZ_DEFSUFFIX_B, 1000);
1013                 if (tsc_freq < 0 || *err) {
1014                     fprintf(stderr, "bad numerical value %s\n", val);
1015                     goto error;
1016                 }
1017                 x86_cpu_def->tsc_khz = tsc_freq / 1000;
1018             } else if (!strcmp(featurestr, "hv_spinlocks")) {
1019                 char *err;
1020                 numvalue = strtoul(val, &err, 0);
1021                 if (!*val || *err) {
1022                     fprintf(stderr, "bad numerical value %s\n", val);
1023                     goto error;
1024                 }
1025                 hyperv_set_spinlock_retries(numvalue);
1026             } else {
1027                 fprintf(stderr, "unrecognized feature %s\n", featurestr);
1028                 goto error;
1029             }
1030         } else if (!strcmp(featurestr, "check")) {
1031             check_cpuid = 1;
1032         } else if (!strcmp(featurestr, "enforce")) {
1033             check_cpuid = enforce_cpuid = 1;
1034         } else if (!strcmp(featurestr, "hv_relaxed")) {
1035             hyperv_enable_relaxed_timing(true);
1036         } else if (!strcmp(featurestr, "hv_vapic")) {
1037             hyperv_enable_vapic_recommended(true);
1038         } else {
1039             fprintf(stderr, "feature string `%s' not in format (+feature|-feature|feature=xyz)\n", featurestr);
1040             goto error;
1041         }
1042         featurestr = strtok(NULL, ",");
1043     }
1044     x86_cpu_def->features |= plus_features;
1045     x86_cpu_def->ext_features |= plus_ext_features;
1046     x86_cpu_def->ext2_features |= plus_ext2_features;
1047     x86_cpu_def->ext3_features |= plus_ext3_features;
1048     x86_cpu_def->kvm_features |= plus_kvm_features;
1049     x86_cpu_def->svm_features |= plus_svm_features;
1050     x86_cpu_def->features &= ~minus_features;
1051     x86_cpu_def->ext_features &= ~minus_ext_features;
1052     x86_cpu_def->ext2_features &= ~minus_ext2_features;
1053     x86_cpu_def->ext3_features &= ~minus_ext3_features;
1054     x86_cpu_def->kvm_features &= ~minus_kvm_features;
1055     x86_cpu_def->svm_features &= ~minus_svm_features;
1056     if (check_cpuid) {
1057         if (check_features_against_host(x86_cpu_def) && enforce_cpuid)
1058             goto error;
1059     }
1060     g_free(s);
1061     return 0;
1062
1063 error:
1064     g_free(s);
1065     return -1;
1066 }
1067
1068 /* generate a composite string into buf of all cpuid names in featureset
1069  * selected by fbits.  indicate truncation at bufsize in the event of overflow.
1070  * if flags, suppress names undefined in featureset.
1071  */
1072 static void listflags(char *buf, int bufsize, uint32_t fbits,
1073     const char **featureset, uint32_t flags)
1074 {
1075     const char **p = &featureset[31];
1076     char *q, *b, bit;
1077     int nc;
1078
1079     b = 4 <= bufsize ? buf + (bufsize -= 3) - 1 : NULL;
1080     *buf = '\0';
1081     for (q = buf, bit = 31; fbits && bufsize; --p, fbits &= ~(1 << bit), --bit)
1082         if (fbits & 1 << bit && (*p || !flags)) {
1083             if (*p)
1084                 nc = snprintf(q, bufsize, "%s%s", q == buf ? "" : " ", *p);
1085             else
1086                 nc = snprintf(q, bufsize, "%s[%d]", q == buf ? "" : " ", bit);
1087             if (bufsize <= nc) {
1088                 if (b) {
1089                     memcpy(b, "...", sizeof("..."));
1090                 }
1091                 return;
1092             }
1093             q += nc;
1094             bufsize -= nc;
1095         }
1096 }
1097
1098 /* generate CPU information:
1099  * -?        list model names
1100  * -?model   list model names/IDs
1101  * -?dump    output all model (x86_def_t) data
1102  * -?cpuid   list all recognized cpuid flag names
1103  */
1104 void x86_cpu_list(FILE *f, fprintf_function cpu_fprintf, const char *optarg)
1105 {
1106     unsigned char model = !strcmp("?model", optarg);
1107     unsigned char dump = !strcmp("?dump", optarg);
1108     unsigned char cpuid = !strcmp("?cpuid", optarg);
1109     x86_def_t *def;
1110     char buf[256];
1111
1112     if (cpuid) {
1113         (*cpu_fprintf)(f, "Recognized CPUID flags:\n");
1114         listflags(buf, sizeof (buf), (uint32_t)~0, feature_name, 1);
1115         (*cpu_fprintf)(f, "  f_edx: %s\n", buf);
1116         listflags(buf, sizeof (buf), (uint32_t)~0, ext_feature_name, 1);
1117         (*cpu_fprintf)(f, "  f_ecx: %s\n", buf);
1118         listflags(buf, sizeof (buf), (uint32_t)~0, ext2_feature_name, 1);
1119         (*cpu_fprintf)(f, "  extf_edx: %s\n", buf);
1120         listflags(buf, sizeof (buf), (uint32_t)~0, ext3_feature_name, 1);
1121         (*cpu_fprintf)(f, "  extf_ecx: %s\n", buf);
1122         return;
1123     }
1124     for (def = x86_defs; def; def = def->next) {
1125         snprintf(buf, sizeof (buf), def->flags ? "[%s]": "%s", def->name);
1126         if (model || dump) {
1127             (*cpu_fprintf)(f, "x86 %16s  %-48s\n", buf, def->model_id);
1128         } else {
1129             (*cpu_fprintf)(f, "x86 %16s\n", buf);
1130         }
1131         if (dump) {
1132             memcpy(buf, &def->vendor1, sizeof (def->vendor1));
1133             memcpy(buf + 4, &def->vendor2, sizeof (def->vendor2));
1134             memcpy(buf + 8, &def->vendor3, sizeof (def->vendor3));
1135             buf[12] = '\0';
1136             (*cpu_fprintf)(f,
1137                 "  family %d model %d stepping %d level %d xlevel 0x%x"
1138                 " vendor \"%s\"\n",
1139                 def->family, def->model, def->stepping, def->level,
1140                 def->xlevel, buf);
1141             listflags(buf, sizeof (buf), def->features, feature_name, 0);
1142             (*cpu_fprintf)(f, "  feature_edx %08x (%s)\n", def->features,
1143                 buf);
1144             listflags(buf, sizeof (buf), def->ext_features, ext_feature_name,
1145                 0);
1146             (*cpu_fprintf)(f, "  feature_ecx %08x (%s)\n", def->ext_features,
1147                 buf);
1148             listflags(buf, sizeof (buf), def->ext2_features, ext2_feature_name,
1149                 0);
1150             (*cpu_fprintf)(f, "  extfeature_edx %08x (%s)\n",
1151                 def->ext2_features, buf);
1152             listflags(buf, sizeof (buf), def->ext3_features, ext3_feature_name,
1153                 0);
1154             (*cpu_fprintf)(f, "  extfeature_ecx %08x (%s)\n",
1155                 def->ext3_features, buf);
1156             (*cpu_fprintf)(f, "\n");
1157         }
1158     }
1159     if (kvm_enabled()) {
1160         (*cpu_fprintf)(f, "x86 %16s\n", "[host]");
1161     }
1162 }
1163
1164 int cpu_x86_register(X86CPU *cpu, const char *cpu_model)
1165 {
1166     CPUX86State *env = &cpu->env;
1167     x86_def_t def1, *def = &def1;
1168     Error *error = NULL;
1169
1170     memset(def, 0, sizeof(*def));
1171
1172     if (cpu_x86_find_by_name(def, cpu_model) < 0)
1173         return -1;
1174     if (def->vendor1) {
1175         env->cpuid_vendor1 = def->vendor1;
1176         env->cpuid_vendor2 = def->vendor2;
1177         env->cpuid_vendor3 = def->vendor3;
1178     } else {
1179         env->cpuid_vendor1 = CPUID_VENDOR_INTEL_1;
1180         env->cpuid_vendor2 = CPUID_VENDOR_INTEL_2;
1181         env->cpuid_vendor3 = CPUID_VENDOR_INTEL_3;
1182     }
1183     env->cpuid_vendor_override = def->vendor_override;
1184     object_property_set_int(OBJECT(cpu), def->level, "level", &error);
1185     object_property_set_int(OBJECT(cpu), def->family, "family", &error);
1186     object_property_set_int(OBJECT(cpu), def->model, "model", &error);
1187     object_property_set_int(OBJECT(cpu), def->stepping, "stepping", &error);
1188     env->cpuid_features = def->features;
1189     env->cpuid_ext_features = def->ext_features;
1190     env->cpuid_ext2_features = def->ext2_features;
1191     env->cpuid_ext3_features = def->ext3_features;
1192     object_property_set_int(OBJECT(cpu), def->xlevel, "xlevel", &error);
1193     env->cpuid_kvm_features = def->kvm_features;
1194     env->cpuid_svm_features = def->svm_features;
1195     env->cpuid_ext4_features = def->ext4_features;
1196     env->cpuid_7_0_ebx = def->cpuid_7_0_ebx_features;
1197     env->cpuid_xlevel2 = def->xlevel2;
1198     object_property_set_int(OBJECT(cpu), (int64_t)def->tsc_khz * 1000,
1199                             "tsc-frequency", &error);
1200     if (!kvm_enabled()) {
1201         env->cpuid_features &= TCG_FEATURES;
1202         env->cpuid_ext_features &= TCG_EXT_FEATURES;
1203         env->cpuid_ext2_features &= (TCG_EXT2_FEATURES
1204 #ifdef TARGET_X86_64
1205             | CPUID_EXT2_SYSCALL | CPUID_EXT2_LM
1206 #endif
1207             );
1208         env->cpuid_ext3_features &= TCG_EXT3_FEATURES;
1209         env->cpuid_svm_features &= TCG_SVM_FEATURES;
1210     }
1211     object_property_set_str(OBJECT(cpu), def->model_id, "model-id", &error);
1212     if (error_is_set(&error)) {
1213         error_free(error);
1214         return -1;
1215     }
1216     return 0;
1217 }
1218
1219 #if !defined(CONFIG_USER_ONLY)
1220 /* copy vendor id string to 32 bit register, nul pad as needed
1221  */
1222 static void cpyid(const char *s, uint32_t *id)
1223 {
1224     char *d = (char *)id;
1225     char i;
1226
1227     for (i = sizeof (*id); i--; )
1228         *d++ = *s ? *s++ : '\0';
1229 }
1230
1231 /* interpret radix and convert from string to arbitrary scalar,
1232  * otherwise flag failure
1233  */
1234 #define setscalar(pval, str, perr)                      \
1235 {                                                       \
1236     char *pend;                                         \
1237     unsigned long ul;                                   \
1238                                                         \
1239     ul = strtoul(str, &pend, 0);                        \
1240     *str && !*pend ? (*pval = ul) : (*perr = 1);        \
1241 }
1242
1243 /* map cpuid options to feature bits, otherwise return failure
1244  * (option tags in *str are delimited by whitespace)
1245  */
1246 static void setfeatures(uint32_t *pval, const char *str,
1247     const char **featureset, int *perr)
1248 {
1249     const char *p, *q;
1250
1251     for (q = p = str; *p || *q; q = p) {
1252         while (iswhite(*p))
1253             q = ++p;
1254         while (*p && !iswhite(*p))
1255             ++p;
1256         if (!*q && !*p)
1257             return;
1258         if (!lookup_feature(pval, q, p, featureset)) {
1259             fprintf(stderr, "error: feature \"%.*s\" not available in set\n",
1260                 (int)(p - q), q);
1261             *perr = 1;
1262             return;
1263         }
1264     }
1265 }
1266
1267 /* map config file options to x86_def_t form
1268  */
1269 static int cpudef_setfield(const char *name, const char *str, void *opaque)
1270 {
1271     x86_def_t *def = opaque;
1272     int err = 0;
1273
1274     if (!strcmp(name, "name")) {
1275         g_free((void *)def->name);
1276         def->name = g_strdup(str);
1277     } else if (!strcmp(name, "model_id")) {
1278         strncpy(def->model_id, str, sizeof (def->model_id));
1279     } else if (!strcmp(name, "level")) {
1280         setscalar(&def->level, str, &err)
1281     } else if (!strcmp(name, "vendor")) {
1282         cpyid(&str[0], &def->vendor1);
1283         cpyid(&str[4], &def->vendor2);
1284         cpyid(&str[8], &def->vendor3);
1285     } else if (!strcmp(name, "family")) {
1286         setscalar(&def->family, str, &err)
1287     } else if (!strcmp(name, "model")) {
1288         setscalar(&def->model, str, &err)
1289     } else if (!strcmp(name, "stepping")) {
1290         setscalar(&def->stepping, str, &err)
1291     } else if (!strcmp(name, "feature_edx")) {
1292         setfeatures(&def->features, str, feature_name, &err);
1293     } else if (!strcmp(name, "feature_ecx")) {
1294         setfeatures(&def->ext_features, str, ext_feature_name, &err);
1295     } else if (!strcmp(name, "extfeature_edx")) {
1296         setfeatures(&def->ext2_features, str, ext2_feature_name, &err);
1297     } else if (!strcmp(name, "extfeature_ecx")) {
1298         setfeatures(&def->ext3_features, str, ext3_feature_name, &err);
1299     } else if (!strcmp(name, "xlevel")) {
1300         setscalar(&def->xlevel, str, &err)
1301     } else {
1302         fprintf(stderr, "error: unknown option [%s = %s]\n", name, str);
1303         return (1);
1304     }
1305     if (err) {
1306         fprintf(stderr, "error: bad option value [%s = %s]\n", name, str);
1307         return (1);
1308     }
1309     return (0);
1310 }
1311
1312 /* register config file entry as x86_def_t
1313  */
1314 static int cpudef_register(QemuOpts *opts, void *opaque)
1315 {
1316     x86_def_t *def = g_malloc0(sizeof (x86_def_t));
1317
1318     qemu_opt_foreach(opts, cpudef_setfield, def, 1);
1319     def->next = x86_defs;
1320     x86_defs = def;
1321     return (0);
1322 }
1323
1324 void cpu_clear_apic_feature(CPUX86State *env)
1325 {
1326     env->cpuid_features &= ~CPUID_APIC;
1327 }
1328
1329 #endif /* !CONFIG_USER_ONLY */
1330
1331 /* register "cpudef" models defined in configuration file.  Here we first
1332  * preload any built-in definitions
1333  */
1334 void x86_cpudef_setup(void)
1335 {
1336     int i;
1337
1338     for (i = 0; i < ARRAY_SIZE(builtin_x86_defs); ++i) {
1339         builtin_x86_defs[i].next = x86_defs;
1340         builtin_x86_defs[i].flags = 1;
1341         x86_defs = &builtin_x86_defs[i];
1342     }
1343 #if !defined(CONFIG_USER_ONLY)
1344     qemu_opts_foreach(qemu_find_opts("cpudef"), cpudef_register, NULL, 0);
1345 #endif
1346 }
1347
1348 static void get_cpuid_vendor(CPUX86State *env, uint32_t *ebx,
1349                              uint32_t *ecx, uint32_t *edx)
1350 {
1351     *ebx = env->cpuid_vendor1;
1352     *edx = env->cpuid_vendor2;
1353     *ecx = env->cpuid_vendor3;
1354
1355     /* sysenter isn't supported on compatibility mode on AMD, syscall
1356      * isn't supported in compatibility mode on Intel.
1357      * Normally we advertise the actual cpu vendor, but you can override
1358      * this if you want to use KVM's sysenter/syscall emulation
1359      * in compatibility mode and when doing cross vendor migration
1360      */
1361     if (kvm_enabled() && ! env->cpuid_vendor_override) {
1362         host_cpuid(0, 0, NULL, ebx, ecx, edx);
1363     }
1364 }
1365
1366 void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
1367                    uint32_t *eax, uint32_t *ebx,
1368                    uint32_t *ecx, uint32_t *edx)
1369 {
1370     /* test if maximum index reached */
1371     if (index & 0x80000000) {
1372         if (index > env->cpuid_xlevel) {
1373             if (env->cpuid_xlevel2 > 0) {
1374                 /* Handle the Centaur's CPUID instruction. */
1375                 if (index > env->cpuid_xlevel2) {
1376                     index = env->cpuid_xlevel2;
1377                 } else if (index < 0xC0000000) {
1378                     index = env->cpuid_xlevel;
1379                 }
1380             } else {
1381                 index =  env->cpuid_xlevel;
1382             }
1383         }
1384     } else {
1385         if (index > env->cpuid_level)
1386             index = env->cpuid_level;
1387     }
1388
1389     switch(index) {
1390     case 0:
1391         *eax = env->cpuid_level;
1392         get_cpuid_vendor(env, ebx, ecx, edx);
1393         break;
1394     case 1:
1395         *eax = env->cpuid_version;
1396         *ebx = (env->cpuid_apic_id << 24) | 8 << 8; /* CLFLUSH size in quad words, Linux wants it. */
1397         *ecx = env->cpuid_ext_features;
1398         *edx = env->cpuid_features;
1399         if (env->nr_cores * env->nr_threads > 1) {
1400             *ebx |= (env->nr_cores * env->nr_threads) << 16;
1401             *edx |= 1 << 28;    /* HTT bit */
1402         }
1403         break;
1404     case 2:
1405         /* cache info: needed for Pentium Pro compatibility */
1406         *eax = 1;
1407         *ebx = 0;
1408         *ecx = 0;
1409         *edx = 0x2c307d;
1410         break;
1411     case 4:
1412         /* cache info: needed for Core compatibility */
1413         if (env->nr_cores > 1) {
1414             *eax = (env->nr_cores - 1) << 26;
1415         } else {
1416             *eax = 0;
1417         }
1418         switch (count) {
1419             case 0: /* L1 dcache info */
1420                 *eax |= 0x0000121;
1421                 *ebx = 0x1c0003f;
1422                 *ecx = 0x000003f;
1423                 *edx = 0x0000001;
1424                 break;
1425             case 1: /* L1 icache info */
1426                 *eax |= 0x0000122;
1427                 *ebx = 0x1c0003f;
1428                 *ecx = 0x000003f;
1429                 *edx = 0x0000001;
1430                 break;
1431             case 2: /* L2 cache info */
1432                 *eax |= 0x0000143;
1433                 if (env->nr_threads > 1) {
1434                     *eax |= (env->nr_threads - 1) << 14;
1435                 }
1436                 *ebx = 0x3c0003f;
1437                 *ecx = 0x0000fff;
1438                 *edx = 0x0000001;
1439                 break;
1440             default: /* end of info */
1441                 *eax = 0;
1442                 *ebx = 0;
1443                 *ecx = 0;
1444                 *edx = 0;
1445                 break;
1446         }
1447         break;
1448     case 5:
1449         /* mwait info: needed for Core compatibility */
1450         *eax = 0; /* Smallest monitor-line size in bytes */
1451         *ebx = 0; /* Largest monitor-line size in bytes */
1452         *ecx = CPUID_MWAIT_EMX | CPUID_MWAIT_IBE;
1453         *edx = 0;
1454         break;
1455     case 6:
1456         /* Thermal and Power Leaf */
1457         *eax = 0;
1458         *ebx = 0;
1459         *ecx = 0;
1460         *edx = 0;
1461         break;
1462     case 7:
1463         /* Structured Extended Feature Flags Enumeration Leaf */
1464         if (count == 0) {
1465             *eax = 0; /* Maximum ECX value for sub-leaves */
1466             *ebx = env->cpuid_7_0_ebx; /* Feature flags */
1467             *ecx = 0; /* Reserved */
1468             *edx = 0; /* Reserved */
1469         } else {
1470             *eax = 0;
1471             *ebx = 0;
1472             *ecx = 0;
1473             *edx = 0;
1474         }
1475         break;
1476     case 9:
1477         /* Direct Cache Access Information Leaf */
1478         *eax = 0; /* Bits 0-31 in DCA_CAP MSR */
1479         *ebx = 0;
1480         *ecx = 0;
1481         *edx = 0;
1482         break;
1483     case 0xA:
1484         /* Architectural Performance Monitoring Leaf */
1485         if (kvm_enabled()) {
1486             KVMState *s = env->kvm_state;
1487
1488             *eax = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EAX);
1489             *ebx = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EBX);
1490             *ecx = kvm_arch_get_supported_cpuid(s, 0xA, count, R_ECX);
1491             *edx = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EDX);
1492         } else {
1493             *eax = 0;
1494             *ebx = 0;
1495             *ecx = 0;
1496             *edx = 0;
1497         }
1498         break;
1499     case 0xD:
1500         /* Processor Extended State */
1501         if (!(env->cpuid_ext_features & CPUID_EXT_XSAVE)) {
1502             *eax = 0;
1503             *ebx = 0;
1504             *ecx = 0;
1505             *edx = 0;
1506             break;
1507         }
1508         if (kvm_enabled()) {
1509             KVMState *s = env->kvm_state;
1510
1511             *eax = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EAX);
1512             *ebx = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EBX);
1513             *ecx = kvm_arch_get_supported_cpuid(s, 0xd, count, R_ECX);
1514             *edx = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EDX);
1515         } else {
1516             *eax = 0;
1517             *ebx = 0;
1518             *ecx = 0;
1519             *edx = 0;
1520         }
1521         break;
1522     case 0x80000000:
1523         *eax = env->cpuid_xlevel;
1524         *ebx = env->cpuid_vendor1;
1525         *edx = env->cpuid_vendor2;
1526         *ecx = env->cpuid_vendor3;
1527         break;
1528     case 0x80000001:
1529         *eax = env->cpuid_version;
1530         *ebx = 0;
1531         *ecx = env->cpuid_ext3_features;
1532         *edx = env->cpuid_ext2_features;
1533
1534         /* The Linux kernel checks for the CMPLegacy bit and
1535          * discards multiple thread information if it is set.
1536          * So dont set it here for Intel to make Linux guests happy.
1537          */
1538         if (env->nr_cores * env->nr_threads > 1) {
1539             uint32_t tebx, tecx, tedx;
1540             get_cpuid_vendor(env, &tebx, &tecx, &tedx);
1541             if (tebx != CPUID_VENDOR_INTEL_1 ||
1542                 tedx != CPUID_VENDOR_INTEL_2 ||
1543                 tecx != CPUID_VENDOR_INTEL_3) {
1544                 *ecx |= 1 << 1;    /* CmpLegacy bit */
1545             }
1546         }
1547         break;
1548     case 0x80000002:
1549     case 0x80000003:
1550     case 0x80000004:
1551         *eax = env->cpuid_model[(index - 0x80000002) * 4 + 0];
1552         *ebx = env->cpuid_model[(index - 0x80000002) * 4 + 1];
1553         *ecx = env->cpuid_model[(index - 0x80000002) * 4 + 2];
1554         *edx = env->cpuid_model[(index - 0x80000002) * 4 + 3];
1555         break;
1556     case 0x80000005:
1557         /* cache info (L1 cache) */
1558         *eax = 0x01ff01ff;
1559         *ebx = 0x01ff01ff;
1560         *ecx = 0x40020140;
1561         *edx = 0x40020140;
1562         break;
1563     case 0x80000006:
1564         /* cache info (L2 cache) */
1565         *eax = 0;
1566         *ebx = 0x42004200;
1567         *ecx = 0x02008140;
1568         *edx = 0;
1569         break;
1570     case 0x80000008:
1571         /* virtual & phys address size in low 2 bytes. */
1572 /* XXX: This value must match the one used in the MMU code. */
1573         if (env->cpuid_ext2_features & CPUID_EXT2_LM) {
1574             /* 64 bit processor */
1575 /* XXX: The physical address space is limited to 42 bits in exec.c. */
1576             *eax = 0x00003028;  /* 48 bits virtual, 40 bits physical */
1577         } else {
1578             if (env->cpuid_features & CPUID_PSE36)
1579                 *eax = 0x00000024; /* 36 bits physical */
1580             else
1581                 *eax = 0x00000020; /* 32 bits physical */
1582         }
1583         *ebx = 0;
1584         *ecx = 0;
1585         *edx = 0;
1586         if (env->nr_cores * env->nr_threads > 1) {
1587             *ecx |= (env->nr_cores * env->nr_threads) - 1;
1588         }
1589         break;
1590     case 0x8000000A:
1591         if (env->cpuid_ext3_features & CPUID_EXT3_SVM) {
1592                 *eax = 0x00000001; /* SVM Revision */
1593                 *ebx = 0x00000010; /* nr of ASIDs */
1594                 *ecx = 0;
1595                 *edx = env->cpuid_svm_features; /* optional features */
1596         } else {
1597                 *eax = 0;
1598                 *ebx = 0;
1599                 *ecx = 0;
1600                 *edx = 0;
1601         }
1602         break;
1603     case 0xC0000000:
1604         *eax = env->cpuid_xlevel2;
1605         *ebx = 0;
1606         *ecx = 0;
1607         *edx = 0;
1608         break;
1609     case 0xC0000001:
1610         /* Support for VIA CPU's CPUID instruction */
1611         *eax = env->cpuid_version;
1612         *ebx = 0;
1613         *ecx = 0;
1614         *edx = env->cpuid_ext4_features;
1615         break;
1616     case 0xC0000002:
1617     case 0xC0000003:
1618     case 0xC0000004:
1619         /* Reserved for the future, and now filled with zero */
1620         *eax = 0;
1621         *ebx = 0;
1622         *ecx = 0;
1623         *edx = 0;
1624         break;
1625     default:
1626         /* reserved values: zero */
1627         *eax = 0;
1628         *ebx = 0;
1629         *ecx = 0;
1630         *edx = 0;
1631         break;
1632     }
1633 }
1634
1635 /* CPUClass::reset() */
1636 static void x86_cpu_reset(CPUState *s)
1637 {
1638     X86CPU *cpu = X86_CPU(s);
1639     X86CPUClass *xcc = X86_CPU_GET_CLASS(cpu);
1640     CPUX86State *env = &cpu->env;
1641     int i;
1642
1643     if (qemu_loglevel_mask(CPU_LOG_RESET)) {
1644         qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
1645         log_cpu_state(env, X86_DUMP_FPU | X86_DUMP_CCOP);
1646     }
1647
1648     xcc->parent_reset(s);
1649
1650
1651     memset(env, 0, offsetof(CPUX86State, breakpoints));
1652
1653     tlb_flush(env, 1);
1654
1655     env->old_exception = -1;
1656
1657     /* init to reset state */
1658
1659 #ifdef CONFIG_SOFTMMU
1660     env->hflags |= HF_SOFTMMU_MASK;
1661 #endif
1662     env->hflags2 |= HF2_GIF_MASK;
1663
1664     cpu_x86_update_cr0(env, 0x60000010);
1665     env->a20_mask = ~0x0;
1666     env->smbase = 0x30000;
1667
1668     env->idt.limit = 0xffff;
1669     env->gdt.limit = 0xffff;
1670     env->ldt.limit = 0xffff;
1671     env->ldt.flags = DESC_P_MASK | (2 << DESC_TYPE_SHIFT);
1672     env->tr.limit = 0xffff;
1673     env->tr.flags = DESC_P_MASK | (11 << DESC_TYPE_SHIFT);
1674
1675     cpu_x86_load_seg_cache(env, R_CS, 0xf000, 0xffff0000, 0xffff,
1676                            DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK |
1677                            DESC_R_MASK | DESC_A_MASK);
1678     cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffff,
1679                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1680                            DESC_A_MASK);
1681     cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffff,
1682                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1683                            DESC_A_MASK);
1684     cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffff,
1685                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1686                            DESC_A_MASK);
1687     cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffff,
1688                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1689                            DESC_A_MASK);
1690     cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffff,
1691                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1692                            DESC_A_MASK);
1693
1694     env->eip = 0xfff0;
1695     env->regs[R_EDX] = env->cpuid_version;
1696
1697     env->eflags = 0x2;
1698
1699     /* FPU init */
1700     for (i = 0; i < 8; i++) {
1701         env->fptags[i] = 1;
1702     }
1703     env->fpuc = 0x37f;
1704
1705     env->mxcsr = 0x1f80;
1706
1707     env->pat = 0x0007040600070406ULL;
1708     env->msr_ia32_misc_enable = MSR_IA32_MISC_ENABLE_DEFAULT;
1709
1710     memset(env->dr, 0, sizeof(env->dr));
1711     env->dr[6] = DR6_FIXED_1;
1712     env->dr[7] = DR7_FIXED_1;
1713     cpu_breakpoint_remove_all(env, BP_CPU);
1714     cpu_watchpoint_remove_all(env, BP_CPU);
1715 }
1716
1717 static void mce_init(X86CPU *cpu)
1718 {
1719     CPUX86State *cenv = &cpu->env;
1720     unsigned int bank;
1721
1722     if (((cenv->cpuid_version >> 8) & 0xf) >= 6
1723         && (cenv->cpuid_features & (CPUID_MCE | CPUID_MCA)) ==
1724             (CPUID_MCE | CPUID_MCA)) {
1725         cenv->mcg_cap = MCE_CAP_DEF | MCE_BANKS_DEF;
1726         cenv->mcg_ctl = ~(uint64_t)0;
1727         for (bank = 0; bank < MCE_BANKS_DEF; bank++) {
1728             cenv->mce_banks[bank * 4] = ~(uint64_t)0;
1729         }
1730     }
1731 }
1732
1733 void x86_cpu_realize(Object *obj, Error **errp)
1734 {
1735     X86CPU *cpu = X86_CPU(obj);
1736
1737     mce_init(cpu);
1738     qemu_init_vcpu(&cpu->env);
1739 }
1740
1741 static void x86_cpu_initfn(Object *obj)
1742 {
1743     X86CPU *cpu = X86_CPU(obj);
1744     CPUX86State *env = &cpu->env;
1745
1746     cpu_exec_init(env);
1747
1748     object_property_add(obj, "family", "int",
1749                         x86_cpuid_version_get_family,
1750                         x86_cpuid_version_set_family, NULL, NULL, NULL);
1751     object_property_add(obj, "model", "int",
1752                         x86_cpuid_version_get_model,
1753                         x86_cpuid_version_set_model, NULL, NULL, NULL);
1754     object_property_add(obj, "stepping", "int",
1755                         x86_cpuid_version_get_stepping,
1756                         x86_cpuid_version_set_stepping, NULL, NULL, NULL);
1757     object_property_add(obj, "level", "int",
1758                         x86_cpuid_get_level,
1759                         x86_cpuid_set_level, NULL, NULL, NULL);
1760     object_property_add(obj, "xlevel", "int",
1761                         x86_cpuid_get_xlevel,
1762                         x86_cpuid_set_xlevel, NULL, NULL, NULL);
1763     object_property_add_str(obj, "vendor",
1764                             x86_cpuid_get_vendor,
1765                             x86_cpuid_set_vendor, NULL);
1766     object_property_add_str(obj, "model-id",
1767                             x86_cpuid_get_model_id,
1768                             x86_cpuid_set_model_id, NULL);
1769     object_property_add(obj, "tsc-frequency", "int",
1770                         x86_cpuid_get_tsc_freq,
1771                         x86_cpuid_set_tsc_freq, NULL, NULL, NULL);
1772
1773     env->cpuid_apic_id = env->cpu_index;
1774 }
1775
1776 static void x86_cpu_common_class_init(ObjectClass *oc, void *data)
1777 {
1778     X86CPUClass *xcc = X86_CPU_CLASS(oc);
1779     CPUClass *cc = CPU_CLASS(oc);
1780
1781     xcc->parent_reset = cc->reset;
1782     cc->reset = x86_cpu_reset;
1783 }
1784
1785 static const TypeInfo x86_cpu_type_info = {
1786     .name = TYPE_X86_CPU,
1787     .parent = TYPE_CPU,
1788     .instance_size = sizeof(X86CPU),
1789     .instance_init = x86_cpu_initfn,
1790     .abstract = false,
1791     .class_size = sizeof(X86CPUClass),
1792     .class_init = x86_cpu_common_class_init,
1793 };
1794
1795 static void x86_cpu_register_types(void)
1796 {
1797     type_register_static(&x86_cpu_type_info);
1798 }
1799
1800 type_init(x86_cpu_register_types)