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 "sysemu/kvm.h"
  26
  27 #include "qemu/option.h"
  28 #include "qemu/config-file.h"
  29 #include "qapi/qmp/qerror.h"
  30
  31 #include "qapi/visitor.h"
  32 #include "sysemu/arch_init.h"
  33
  34 #include "hyperv.h"
  35
  36 #include "hw/hw.h"
  37 #if defined(CONFIG_KVM)
  38 #include <linux/kvm_para.h>
  39 #endif
  40
  41 #include "sysemu/sysemu.h"
  42 #ifndef CONFIG_USER_ONLY
  43 #include "hw/xen.h"
  44 #include "hw/sysbus.h"
  45 #include "hw/apic_internal.h"
  46 #endif
  47
  48 /* feature flags taken from "Intel Processor Identification and the CPUID
  49  * Instruction" and AMD's "CPUID Specification".  In cases of disagreement
  50  * between feature naming conventions, aliases may be added.
  51  */
  52 static const char *feature_name[] = {
  53     "fpu", "vme", "de", "pse",
  54     "tsc", "msr", "pae", "mce",
  55     "cx8", "apic", NULL, "sep",
  56     "mtrr", "pge", "mca", "cmov",
  57     "pat", "pse36", "pn" /* Intel psn */, "clflush" /* Intel clfsh */,
  58     NULL, "ds" /* Intel dts */, "acpi", "mmx",
  59     "fxsr", "sse", "sse2", "ss",
  60     "ht" /* Intel htt */, "tm", "ia64", "pbe",
  61 };
  62 static const char *ext_feature_name[] = {
  63     "pni|sse3" /* Intel,AMD sse3 */, "pclmulqdq|pclmuldq", "dtes64", "monitor",
  64     "ds_cpl", "vmx", "smx", "est",
  65     "tm2", "ssse3", "cid", NULL,
  66     "fma", "cx16", "xtpr", "pdcm",
  67     NULL, "pcid", "dca", "sse4.1|sse4_1",
  68     "sse4.2|sse4_2", "x2apic", "movbe", "popcnt",
  69     "tsc-deadline", "aes", "xsave", "osxsave",
  70     "avx", "f16c", "rdrand", "hypervisor",
  71 };
  72 /* Feature names that are already defined on feature_name[] but are set on
  73  * CPUID[8000_0001].EDX on AMD CPUs don't have their names on
  74  * ext2_feature_name[]. They are copied automatically to cpuid_ext2_features
  75  * if and only if CPU vendor is AMD.
  76  */
  77 static const char *ext2_feature_name[] = {
  78     NULL /* fpu */, NULL /* vme */, NULL /* de */, NULL /* pse */,
  79     NULL /* tsc */, NULL /* msr */, NULL /* pae */, NULL /* mce */,
  80     NULL /* cx8 */ /* AMD CMPXCHG8B */, NULL /* apic */, NULL, "syscall",
  81     NULL /* mtrr */, NULL /* pge */, NULL /* mca */, NULL /* cmov */,
  82     NULL /* pat */, NULL /* pse36 */, NULL, NULL /* Linux mp */,
  83     "nx|xd", NULL, "mmxext", NULL /* mmx */,
  84     NULL /* fxsr */, "fxsr_opt|ffxsr", "pdpe1gb" /* AMD Page1GB */, "rdtscp",
  85     NULL, "lm|i64", "3dnowext", "3dnow",
  86 };
  87 static const char *ext3_feature_name[] = {
  88     "lahf_lm" /* AMD LahfSahf */, "cmp_legacy", "svm", "extapic" /* AMD ExtApicSpace */,
  89     "cr8legacy" /* AMD AltMovCr8 */, "abm", "sse4a", "misalignsse",
  90     "3dnowprefetch", "osvw", "ibs", "xop",
  91     "skinit", "wdt", NULL, "lwp",
  92     "fma4", "tce", NULL, "nodeid_msr",
  93     NULL, "tbm", "topoext", "perfctr_core",
  94     "perfctr_nb", NULL, NULL, NULL,
  95     NULL, NULL, NULL, NULL,
  96 };
  97
  98 static const char *kvm_feature_name[] = {
  99     "kvmclock", "kvm_nopiodelay", "kvm_mmu", "kvmclock",
 100     "kvm_asyncpf", "kvm_steal_time", "kvm_pv_eoi", NULL,
 101     NULL, NULL, NULL, NULL,
 102     NULL, NULL, NULL, NULL,
 103     NULL, NULL, NULL, NULL,
 104     NULL, NULL, NULL, NULL,
 105     NULL, NULL, NULL, NULL,
 106     NULL, NULL, NULL, NULL,
 107 };
 108
 109 static const char *svm_feature_name[] = {
 110     "npt", "lbrv", "svm_lock", "nrip_save",
 111     "tsc_scale", "vmcb_clean",  "flushbyasid", "decodeassists",
 112     NULL, NULL, "pause_filter", NULL,
 113     "pfthreshold", NULL, NULL, NULL,
 114     NULL, NULL, NULL, NULL,
 115     NULL, NULL, NULL, NULL,
 116     NULL, NULL, NULL, NULL,
 117     NULL, NULL, NULL, NULL,
 118 };
 119
 120 static const char *cpuid_7_0_ebx_feature_name[] = {
 121     "fsgsbase", NULL, NULL, "bmi1", "hle", "avx2", NULL, "smep",
 122     "bmi2", "erms", "invpcid", "rtm", NULL, NULL, NULL, NULL,
 123     NULL, NULL, "rdseed", "adx", "smap", NULL, NULL, NULL,
 124     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 125 };
 126
 127 /* collects per-function cpuid data
 128  */
 129 typedef struct model_features_t {
 130     uint32_t *guest_feat;
 131     uint32_t *host_feat;
 132     uint32_t check_feat;
 133     const char **flag_names;
 134     uint32_t cpuid;
 135     } model_features_t;
 136
 137 int check_cpuid = 0;
 138 int enforce_cpuid = 0;
 139
 140 #if defined(CONFIG_KVM)
 141 static uint32_t kvm_default_features = (1 << KVM_FEATURE_CLOCKSOURCE) |
 142         (1 << KVM_FEATURE_NOP_IO_DELAY) |
 143         (1 << KVM_FEATURE_MMU_OP) |
 144         (1 << KVM_FEATURE_CLOCKSOURCE2) |
 145         (1 << KVM_FEATURE_ASYNC_PF) |
 146         (1 << KVM_FEATURE_STEAL_TIME) |
 147         (1 << KVM_FEATURE_CLOCKSOURCE_STABLE_BIT);
 148 static const uint32_t kvm_pv_eoi_features = (0x1 << KVM_FEATURE_PV_EOI);
 149 #else
 150 static uint32_t kvm_default_features = 0;
 151 static const uint32_t kvm_pv_eoi_features = 0;
 152 #endif
 153
 154 void enable_kvm_pv_eoi(void)
 155 {
 156     kvm_default_features |= kvm_pv_eoi_features;
 157 }
 158
 159 void host_cpuid(uint32_t function, uint32_t count,
 160                 uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx)
 161 {
 162 #if defined(CONFIG_KVM)
 163     uint32_t vec[4];
 164
 165 #ifdef __x86_64__
 166     asm volatile("cpuid"
 167                  : "=a"(vec[0]), "=b"(vec[1]),
 168                    "=c"(vec[2]), "=d"(vec[3])
 169                  : "0"(function), "c"(count) : "cc");
 170 #else
 171     asm volatile("pusha \n\t"
 172                  "cpuid \n\t"
 173                  "mov %%eax, 0(%2) \n\t"
 174                  "mov %%ebx, 4(%2) \n\t"
 175                  "mov %%ecx, 8(%2) \n\t"
 176                  "mov %%edx, 12(%2) \n\t"
 177                  "popa"
 178                  : : "a"(function), "c"(count), "S"(vec)
 179                  : "memory", "cc");
 180 #endif
 181
 182     if (eax)
 183         *eax = vec[0];
 184     if (ebx)
 185         *ebx = vec[1];
 186     if (ecx)
 187         *ecx = vec[2];
 188     if (edx)
 189         *edx = vec[3];
 190 #endif
 191 }
 192
 193 #define iswhite(c) ((c) && ((c) <= ' ' || '~' < (c)))
 194
 195 /* general substring compare of *[s1..e1) and *[s2..e2).  sx is start of
 196  * a substring.  ex if !NULL points to the first char after a substring,
 197  * otherwise the string is assumed to sized by a terminating nul.
 198  * Return lexical ordering of *s1:*s2.
 199  */
 200 static int sstrcmp(const char *s1, const char *e1, const char *s2,
 201     const char *e2)
 202 {
 203     for (;;) {
 204         if (!*s1 || !*s2 || *s1 != *s2)
 205             return (*s1 - *s2);
 206         ++s1, ++s2;
 207         if (s1 == e1 && s2 == e2)
 208             return (0);
 209         else if (s1 == e1)
 210             return (*s2);
 211         else if (s2 == e2)
 212             return (*s1);
 213     }
 214 }
 215
 216 /* compare *[s..e) to *altstr.  *altstr may be a simple string or multiple
 217  * '|' delimited (possibly empty) strings in which case search for a match
 218  * within the alternatives proceeds left to right.  Return 0 for success,
 219  * non-zero otherwise.
 220  */
 221 static int altcmp(const char *s, const char *e, const char *altstr)
 222 {
 223     const char *p, *q;
 224
 225     for (q = p = altstr; ; ) {
 226         while (*p && *p != '|')
 227             ++p;
 228         if ((q == p && !*s) || (q != p && !sstrcmp(s, e, q, p)))
 229             return (0);
 230         if (!*p)
 231             return (1);
 232         else
 233             q = ++p;
 234     }
 235 }
 236
 237 /* search featureset for flag *[s..e), if found set corresponding bit in
 238  * *pval and return true, otherwise return false
 239  */
 240 static bool lookup_feature(uint32_t *pval, const char *s, const char *e,
 241                            const char **featureset)
 242 {
 243     uint32_t mask;
 244     const char **ppc;
 245     bool found = false;
 246
 247     for (mask = 1, ppc = featureset; mask; mask <<= 1, ++ppc) {
 248         if (*ppc && !altcmp(s, e, *ppc)) {
 249             *pval |= mask;
 250             found = true;
 251         }
 252     }
 253     return found;
 254 }
 255
 256 static void add_flagname_to_bitmaps(const char *flagname, uint32_t *features,
 257                                     uint32_t *ext_features,
 258                                     uint32_t *ext2_features,
 259                                     uint32_t *ext3_features,
 260                                     uint32_t *kvm_features,
 261                                     uint32_t *svm_features,
 262                                     uint32_t *cpuid_7_0_ebx_features)
 263 {
 264     if (!lookup_feature(features, flagname, NULL, feature_name) &&
 265         !lookup_feature(ext_features, flagname, NULL, ext_feature_name) &&
 266         !lookup_feature(ext2_features, flagname, NULL, ext2_feature_name) &&
 267         !lookup_feature(ext3_features, flagname, NULL, ext3_feature_name) &&
 268         !lookup_feature(kvm_features, flagname, NULL, kvm_feature_name) &&
 269         !lookup_feature(svm_features, flagname, NULL, svm_feature_name) &&
 270         !lookup_feature(cpuid_7_0_ebx_features, flagname, NULL,
 271                         cpuid_7_0_ebx_feature_name))
 272             fprintf(stderr, "CPU feature %s not found\n", flagname);
 273 }
 274
 275 typedef struct x86_def_t {
 276     struct x86_def_t *next;
 277     const char *name;
 278     uint32_t level;
 279     uint32_t vendor1, vendor2, vendor3;
 280     int family;
 281     int model;
 282     int stepping;
 283     int tsc_khz;
 284     uint32_t features, ext_features, ext2_features, ext3_features;
 285     uint32_t kvm_features, svm_features;
 286     uint32_t xlevel;
 287     char model_id[48];
 288     int vendor_override;
 289     /* Store the results of Centaur's CPUID instructions */
 290     uint32_t ext4_features;
 291     uint32_t xlevel2;
 292     /* The feature bits on CPUID[EAX=7,ECX=0].EBX */
 293     uint32_t cpuid_7_0_ebx_features;
 294 } x86_def_t;
 295
 296 #define I486_FEATURES (CPUID_FP87 | CPUID_VME | CPUID_PSE)
 297 #define PENTIUM_FEATURES (I486_FEATURES | CPUID_DE | CPUID_TSC | \
 298           CPUID_MSR | CPUID_MCE | CPUID_CX8 | CPUID_MMX | CPUID_APIC)
 299 #define PENTIUM2_FEATURES (PENTIUM_FEATURES | CPUID_PAE | CPUID_SEP | \
 300           CPUID_MTRR | CPUID_PGE | CPUID_MCA | CPUID_CMOV | CPUID_PAT | \
 301           CPUID_PSE36 | CPUID_FXSR)
 302 #define PENTIUM3_FEATURES (PENTIUM2_FEATURES | CPUID_SSE)
 303 #define PPRO_FEATURES (CPUID_FP87 | CPUID_DE | CPUID_PSE | CPUID_TSC | \
 304           CPUID_MSR | CPUID_MCE | CPUID_CX8 | CPUID_PGE | CPUID_CMOV | \
 305           CPUID_PAT | CPUID_FXSR | CPUID_MMX | CPUID_SSE | CPUID_SSE2 | \
 306           CPUID_PAE | CPUID_SEP | CPUID_APIC)
 307
 308 #define TCG_FEATURES (CPUID_FP87 | CPUID_PSE | CPUID_TSC | CPUID_MSR | \
 309           CPUID_PAE | CPUID_MCE | CPUID_CX8 | CPUID_APIC | CPUID_SEP | \
 310           CPUID_MTRR | CPUID_PGE | CPUID_MCA | CPUID_CMOV | CPUID_PAT | \
 311           CPUID_PSE36 | CPUID_CLFLUSH | CPUID_ACPI | CPUID_MMX | \
 312           CPUID_FXSR | CPUID_SSE | CPUID_SSE2 | CPUID_SS)
 313           /* partly implemented:
 314           CPUID_MTRR, CPUID_MCA, CPUID_CLFLUSH (needed for Win64)
 315           CPUID_PSE36 (needed for Solaris) */
 316           /* missing:
 317           CPUID_VME, CPUID_DTS, CPUID_SS, CPUID_HT, CPUID_TM, CPUID_PBE */
 318 #define TCG_EXT_FEATURES (CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | \
 319           CPUID_EXT_SSSE3 | CPUID_EXT_CX16 | CPUID_EXT_POPCNT | \
 320           CPUID_EXT_HYPERVISOR)
 321           /* missing:
 322           CPUID_EXT_DTES64, CPUID_EXT_DSCPL, CPUID_EXT_VMX, CPUID_EXT_EST,
 323           CPUID_EXT_TM2, CPUID_EXT_XTPR, CPUID_EXT_PDCM, CPUID_EXT_XSAVE */
 324 #define TCG_EXT2_FEATURES ((TCG_FEATURES & CPUID_EXT2_AMD_ALIASES) | \
 325           CPUID_EXT2_NX | CPUID_EXT2_MMXEXT | CPUID_EXT2_RDTSCP | \
 326           CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT)
 327           /* missing:
 328           CPUID_EXT2_PDPE1GB */
 329 #define TCG_EXT3_FEATURES (CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM | \
 330           CPUID_EXT3_CR8LEG | CPUID_EXT3_ABM | CPUID_EXT3_SSE4A)
 331 #define TCG_SVM_FEATURES 0
 332 #define TCG_7_0_EBX_FEATURES (CPUID_7_0_EBX_SMEP | CPUID_7_0_EBX_SMAP)
 333
 334 /* maintains list of cpu model definitions
 335  */
 336 static x86_def_t *x86_defs = {NULL};
 337
 338 /* built-in cpu model definitions (deprecated)
 339  */
 340 static x86_def_t builtin_x86_defs[] = {
 341     {
 342         .name = "qemu64",
 343         .level = 4,
 344         .vendor1 = CPUID_VENDOR_AMD_1,
 345         .vendor2 = CPUID_VENDOR_AMD_2,
 346         .vendor3 = CPUID_VENDOR_AMD_3,
 347         .family = 6,
 348         .model = 2,
 349         .stepping = 3,
 350         .features = PPRO_FEATURES |
 351             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
 352             CPUID_PSE36,
 353         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_CX16 | CPUID_EXT_POPCNT,
 354         .ext2_features = (PPRO_FEATURES & CPUID_EXT2_AMD_ALIASES) |
 355             CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
 356         .ext3_features = CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM |
 357             CPUID_EXT3_ABM | CPUID_EXT3_SSE4A,
 358         .xlevel = 0x8000000A,
 359     },
 360     {
 361         .name = "phenom",
 362         .level = 5,
 363         .vendor1 = CPUID_VENDOR_AMD_1,
 364         .vendor2 = CPUID_VENDOR_AMD_2,
 365         .vendor3 = CPUID_VENDOR_AMD_3,
 366         .family = 16,
 367         .model = 2,
 368         .stepping = 3,
 369         .features = PPRO_FEATURES |
 370             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
 371             CPUID_PSE36 | CPUID_VME | CPUID_HT,
 372         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_CX16 |
 373             CPUID_EXT_POPCNT,
 374         .ext2_features = (PPRO_FEATURES & CPUID_EXT2_AMD_ALIASES) |
 375             CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX |
 376             CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT | CPUID_EXT2_MMXEXT |
 377             CPUID_EXT2_FFXSR | CPUID_EXT2_PDPE1GB | CPUID_EXT2_RDTSCP,
 378         /* Missing: CPUID_EXT3_CMP_LEG, CPUID_EXT3_EXTAPIC,
 379                     CPUID_EXT3_CR8LEG,
 380                     CPUID_EXT3_MISALIGNSSE, CPUID_EXT3_3DNOWPREFETCH,
 381                     CPUID_EXT3_OSVW, CPUID_EXT3_IBS */
 382         .ext3_features = CPUID_EXT3_LAHF_LM | CPUID_EXT3_SVM |
 383             CPUID_EXT3_ABM | CPUID_EXT3_SSE4A,
 384         .svm_features = CPUID_SVM_NPT | CPUID_SVM_LBRV,
 385         .xlevel = 0x8000001A,
 386         .model_id = "AMD Phenom(tm) 9550 Quad-Core Processor"
 387     },
 388     {
 389         .name = "core2duo",
 390         .level = 10,
 391         .family = 6,
 392         .model = 15,
 393         .stepping = 11,
 394         .features = PPRO_FEATURES |
 395             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
 396             CPUID_PSE36 | CPUID_VME | CPUID_DTS | CPUID_ACPI | CPUID_SS |
 397             CPUID_HT | CPUID_TM | CPUID_PBE,
 398         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_SSSE3 |
 399             CPUID_EXT_DTES64 | CPUID_EXT_DSCPL | CPUID_EXT_VMX | CPUID_EXT_EST |
 400             CPUID_EXT_TM2 | CPUID_EXT_CX16 | CPUID_EXT_XTPR | CPUID_EXT_PDCM,
 401         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
 402         .ext3_features = CPUID_EXT3_LAHF_LM,
 403         .xlevel = 0x80000008,
 404         .model_id = "Intel(R) Core(TM)2 Duo CPU     T7700  @ 2.40GHz",
 405     },
 406     {
 407         .name = "kvm64",
 408         .level = 5,
 409         .vendor1 = CPUID_VENDOR_INTEL_1,
 410         .vendor2 = CPUID_VENDOR_INTEL_2,
 411         .vendor3 = CPUID_VENDOR_INTEL_3,
 412         .family = 15,
 413         .model = 6,
 414         .stepping = 1,
 415         /* Missing: CPUID_VME, CPUID_HT */
 416         .features = PPRO_FEATURES |
 417             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA |
 418             CPUID_PSE36,
 419         /* Missing: CPUID_EXT_POPCNT, CPUID_EXT_MONITOR */
 420         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_CX16,
 421         /* Missing: CPUID_EXT2_PDPE1GB, CPUID_EXT2_RDTSCP */
 422         .ext2_features = (PPRO_FEATURES & CPUID_EXT2_AMD_ALIASES) |
 423             CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
 424         /* Missing: CPUID_EXT3_LAHF_LM, CPUID_EXT3_CMP_LEG, CPUID_EXT3_EXTAPIC,
 425                     CPUID_EXT3_CR8LEG, CPUID_EXT3_ABM, CPUID_EXT3_SSE4A,
 426                     CPUID_EXT3_MISALIGNSSE, CPUID_EXT3_3DNOWPREFETCH,
 427                     CPUID_EXT3_OSVW, CPUID_EXT3_IBS, CPUID_EXT3_SVM */
 428         .ext3_features = 0,
 429         .xlevel = 0x80000008,
 430         .model_id = "Common KVM processor"
 431     },
 432     {
 433         .name = "qemu32",
 434         .level = 4,
 435         .family = 6,
 436         .model = 3,
 437         .stepping = 3,
 438         .features = PPRO_FEATURES,
 439         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_POPCNT,
 440         .xlevel = 0x80000004,
 441     },
 442     {
 443         .name = "kvm32",
 444         .level = 5,
 445         .family = 15,
 446         .model = 6,
 447         .stepping = 1,
 448         .features = PPRO_FEATURES |
 449             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | CPUID_PSE36,
 450         .ext_features = CPUID_EXT_SSE3,
 451         .ext2_features = PPRO_FEATURES & CPUID_EXT2_AMD_ALIASES,
 452         .ext3_features = 0,
 453         .xlevel = 0x80000008,
 454         .model_id = "Common 32-bit KVM processor"
 455     },
 456     {
 457         .name = "coreduo",
 458         .level = 10,
 459         .family = 6,
 460         .model = 14,
 461         .stepping = 8,
 462         .features = PPRO_FEATURES | CPUID_VME |
 463             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | CPUID_DTS | CPUID_ACPI |
 464             CPUID_SS | CPUID_HT | CPUID_TM | CPUID_PBE,
 465         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_VMX |
 466             CPUID_EXT_EST | CPUID_EXT_TM2 | CPUID_EXT_XTPR | CPUID_EXT_PDCM,
 467         .ext2_features = CPUID_EXT2_NX,
 468         .xlevel = 0x80000008,
 469         .model_id = "Genuine Intel(R) CPU           T2600  @ 2.16GHz",
 470     },
 471     {
 472         .name = "486",
 473         .level = 1,
 474         .family = 4,
 475         .model = 0,
 476         .stepping = 0,
 477         .features = I486_FEATURES,
 478         .xlevel = 0,
 479     },
 480     {
 481         .name = "pentium",
 482         .level = 1,
 483         .family = 5,
 484         .model = 4,
 485         .stepping = 3,
 486         .features = PENTIUM_FEATURES,
 487         .xlevel = 0,
 488     },
 489     {
 490         .name = "pentium2",
 491         .level = 2,
 492         .family = 6,
 493         .model = 5,
 494         .stepping = 2,
 495         .features = PENTIUM2_FEATURES,
 496         .xlevel = 0,
 497     },
 498     {
 499         .name = "pentium3",
 500         .level = 2,
 501         .family = 6,
 502         .model = 7,
 503         .stepping = 3,
 504         .features = PENTIUM3_FEATURES,
 505         .xlevel = 0,
 506     },
 507     {
 508         .name = "athlon",
 509         .level = 2,
 510         .vendor1 = CPUID_VENDOR_AMD_1,
 511         .vendor2 = CPUID_VENDOR_AMD_2,
 512         .vendor3 = CPUID_VENDOR_AMD_3,
 513         .family = 6,
 514         .model = 2,
 515         .stepping = 3,
 516         .features = PPRO_FEATURES | CPUID_PSE36 | CPUID_VME | CPUID_MTRR |
 517             CPUID_MCA,
 518         .ext2_features = (PPRO_FEATURES & CPUID_EXT2_AMD_ALIASES) |
 519             CPUID_EXT2_MMXEXT | CPUID_EXT2_3DNOW | CPUID_EXT2_3DNOWEXT,
 520         .xlevel = 0x80000008,
 521     },
 522     {
 523         .name = "n270",
 524         /* original is on level 10 */
 525         .level = 5,
 526         .family = 6,
 527         .model = 28,
 528         .stepping = 2,
 529         .features = PPRO_FEATURES |
 530             CPUID_MTRR | CPUID_CLFLUSH | CPUID_MCA | CPUID_VME | CPUID_DTS |
 531             CPUID_ACPI | CPUID_SS | CPUID_HT | CPUID_TM | CPUID_PBE,
 532             /* Some CPUs got no CPUID_SEP */
 533         .ext_features = CPUID_EXT_SSE3 | CPUID_EXT_MONITOR | CPUID_EXT_SSSE3 |
 534             CPUID_EXT_DSCPL | CPUID_EXT_EST | CPUID_EXT_TM2 | CPUID_EXT_XTPR,
 535         .ext2_features = (PPRO_FEATURES & CPUID_EXT2_AMD_ALIASES) |
 536             CPUID_EXT2_NX,
 537         .ext3_features = CPUID_EXT3_LAHF_LM,
 538         .xlevel = 0x8000000A,
 539         .model_id = "Intel(R) Atom(TM) CPU N270   @ 1.60GHz",
 540     },
 541     {
 542         .name = "Conroe",
 543         .level = 2,
 544         .vendor1 = CPUID_VENDOR_INTEL_1,
 545         .vendor2 = CPUID_VENDOR_INTEL_2,
 546         .vendor3 = CPUID_VENDOR_INTEL_3,
 547         .family = 6,
 548         .model = 2,
 549         .stepping = 3,
 550         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 551              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 552              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 553              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 554              CPUID_DE | CPUID_FP87,
 555         .ext_features = CPUID_EXT_SSSE3 | CPUID_EXT_SSE3,
 556         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_NX | CPUID_EXT2_SYSCALL,
 557         .ext3_features = CPUID_EXT3_LAHF_LM,
 558         .xlevel = 0x8000000A,
 559         .model_id = "Intel Celeron_4x0 (Conroe/Merom Class Core 2)",
 560     },
 561     {
 562         .name = "Penryn",
 563         .level = 2,
 564         .vendor1 = CPUID_VENDOR_INTEL_1,
 565         .vendor2 = CPUID_VENDOR_INTEL_2,
 566         .vendor3 = CPUID_VENDOR_INTEL_3,
 567         .family = 6,
 568         .model = 2,
 569         .stepping = 3,
 570         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 571              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 572              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 573              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 574              CPUID_DE | CPUID_FP87,
 575         .ext_features = CPUID_EXT_SSE41 | CPUID_EXT_CX16 | CPUID_EXT_SSSE3 |
 576              CPUID_EXT_SSE3,
 577         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_NX | CPUID_EXT2_SYSCALL,
 578         .ext3_features = CPUID_EXT3_LAHF_LM,
 579         .xlevel = 0x8000000A,
 580         .model_id = "Intel Core 2 Duo P9xxx (Penryn Class Core 2)",
 581     },
 582     {
 583         .name = "Nehalem",
 584         .level = 2,
 585         .vendor1 = CPUID_VENDOR_INTEL_1,
 586         .vendor2 = CPUID_VENDOR_INTEL_2,
 587         .vendor3 = CPUID_VENDOR_INTEL_3,
 588         .family = 6,
 589         .model = 2,
 590         .stepping = 3,
 591         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 592              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 593              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 594              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 595              CPUID_DE | CPUID_FP87,
 596         .ext_features = CPUID_EXT_POPCNT | CPUID_EXT_SSE42 | CPUID_EXT_SSE41 |
 597              CPUID_EXT_CX16 | CPUID_EXT_SSSE3 | CPUID_EXT_SSE3,
 598         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
 599         .ext3_features = CPUID_EXT3_LAHF_LM,
 600         .xlevel = 0x8000000A,
 601         .model_id = "Intel Core i7 9xx (Nehalem Class Core i7)",
 602     },
 603     {
 604         .name = "Westmere",
 605         .level = 11,
 606         .vendor1 = CPUID_VENDOR_INTEL_1,
 607         .vendor2 = CPUID_VENDOR_INTEL_2,
 608         .vendor3 = CPUID_VENDOR_INTEL_3,
 609         .family = 6,
 610         .model = 44,
 611         .stepping = 1,
 612         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 613              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 614              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 615              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 616              CPUID_DE | CPUID_FP87,
 617         .ext_features = CPUID_EXT_AES | CPUID_EXT_POPCNT | CPUID_EXT_SSE42 |
 618              CPUID_EXT_SSE41 | CPUID_EXT_CX16 | CPUID_EXT_SSSE3 |
 619              CPUID_EXT_SSE3,
 620         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_SYSCALL | CPUID_EXT2_NX,
 621         .ext3_features = CPUID_EXT3_LAHF_LM,
 622         .xlevel = 0x8000000A,
 623         .model_id = "Westmere E56xx/L56xx/X56xx (Nehalem-C)",
 624     },
 625     {
 626         .name = "SandyBridge",
 627         .level = 0xd,
 628         .vendor1 = CPUID_VENDOR_INTEL_1,
 629         .vendor2 = CPUID_VENDOR_INTEL_2,
 630         .vendor3 = CPUID_VENDOR_INTEL_3,
 631         .family = 6,
 632         .model = 42,
 633         .stepping = 1,
 634         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 635              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 636              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 637              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 638              CPUID_DE | CPUID_FP87,
 639         .ext_features = CPUID_EXT_AVX | CPUID_EXT_XSAVE | CPUID_EXT_AES |
 640              CPUID_EXT_TSC_DEADLINE_TIMER | CPUID_EXT_POPCNT |
 641              CPUID_EXT_X2APIC | CPUID_EXT_SSE42 | CPUID_EXT_SSE41 |
 642              CPUID_EXT_CX16 | CPUID_EXT_SSSE3 | CPUID_EXT_PCLMULQDQ |
 643              CPUID_EXT_SSE3,
 644         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_RDTSCP | CPUID_EXT2_NX |
 645              CPUID_EXT2_SYSCALL,
 646         .ext3_features = CPUID_EXT3_LAHF_LM,
 647         .xlevel = 0x8000000A,
 648         .model_id = "Intel Xeon E312xx (Sandy Bridge)",
 649     },
 650     {
 651         .name = "Haswell",
 652         .level = 0xd,
 653         .vendor1 = CPUID_VENDOR_INTEL_1,
 654         .vendor2 = CPUID_VENDOR_INTEL_2,
 655         .vendor3 = CPUID_VENDOR_INTEL_3,
 656         .family = 6,
 657         .model = 60,
 658         .stepping = 1,
 659         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 660              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 661              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 662              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 663              CPUID_DE | CPUID_FP87,
 664         .ext_features = CPUID_EXT_AVX | CPUID_EXT_XSAVE | CPUID_EXT_AES |
 665              CPUID_EXT_POPCNT | CPUID_EXT_X2APIC | CPUID_EXT_SSE42 |
 666              CPUID_EXT_SSE41 | CPUID_EXT_CX16 | CPUID_EXT_SSSE3 |
 667              CPUID_EXT_PCLMULQDQ | CPUID_EXT_SSE3 |
 668              CPUID_EXT_TSC_DEADLINE_TIMER | CPUID_EXT_FMA | CPUID_EXT_MOVBE |
 669              CPUID_EXT_PCID,
 670         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_RDTSCP | CPUID_EXT2_NX |
 671              CPUID_EXT2_SYSCALL,
 672         .ext3_features = CPUID_EXT3_LAHF_LM,
 673         .cpuid_7_0_ebx_features = CPUID_7_0_EBX_FSGSBASE | CPUID_7_0_EBX_BMI1 |
 674             CPUID_7_0_EBX_HLE | CPUID_7_0_EBX_AVX2 | CPUID_7_0_EBX_SMEP |
 675             CPUID_7_0_EBX_BMI2 | CPUID_7_0_EBX_ERMS | CPUID_7_0_EBX_INVPCID |
 676             CPUID_7_0_EBX_RTM,
 677         .xlevel = 0x8000000A,
 678         .model_id = "Intel Core Processor (Haswell)",
 679     },
 680     {
 681         .name = "Opteron_G1",
 682         .level = 5,
 683         .vendor1 = CPUID_VENDOR_AMD_1,
 684         .vendor2 = CPUID_VENDOR_AMD_2,
 685         .vendor3 = CPUID_VENDOR_AMD_3,
 686         .family = 15,
 687         .model = 6,
 688         .stepping = 1,
 689         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 690              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 691              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 692              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 693              CPUID_DE | CPUID_FP87,
 694         .ext_features = CPUID_EXT_SSE3,
 695         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_FXSR | CPUID_EXT2_MMX |
 696              CPUID_EXT2_NX | CPUID_EXT2_PSE36 | CPUID_EXT2_PAT |
 697              CPUID_EXT2_CMOV | CPUID_EXT2_MCA | CPUID_EXT2_PGE |
 698              CPUID_EXT2_MTRR | CPUID_EXT2_SYSCALL | CPUID_EXT2_APIC |
 699              CPUID_EXT2_CX8 | CPUID_EXT2_MCE | CPUID_EXT2_PAE | CPUID_EXT2_MSR |
 700              CPUID_EXT2_TSC | CPUID_EXT2_PSE | CPUID_EXT2_DE | CPUID_EXT2_FPU,
 701         .xlevel = 0x80000008,
 702         .model_id = "AMD Opteron 240 (Gen 1 Class Opteron)",
 703     },
 704     {
 705         .name = "Opteron_G2",
 706         .level = 5,
 707         .vendor1 = CPUID_VENDOR_AMD_1,
 708         .vendor2 = CPUID_VENDOR_AMD_2,
 709         .vendor3 = CPUID_VENDOR_AMD_3,
 710         .family = 15,
 711         .model = 6,
 712         .stepping = 1,
 713         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 714              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 715              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 716              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 717              CPUID_DE | CPUID_FP87,
 718         .ext_features = CPUID_EXT_CX16 | CPUID_EXT_SSE3,
 719         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_RDTSCP | CPUID_EXT2_FXSR |
 720              CPUID_EXT2_MMX | CPUID_EXT2_NX | CPUID_EXT2_PSE36 |
 721              CPUID_EXT2_PAT | CPUID_EXT2_CMOV | CPUID_EXT2_MCA |
 722              CPUID_EXT2_PGE | CPUID_EXT2_MTRR | CPUID_EXT2_SYSCALL |
 723              CPUID_EXT2_APIC | CPUID_EXT2_CX8 | CPUID_EXT2_MCE |
 724              CPUID_EXT2_PAE | CPUID_EXT2_MSR | CPUID_EXT2_TSC | CPUID_EXT2_PSE |
 725              CPUID_EXT2_DE | CPUID_EXT2_FPU,
 726         .ext3_features = CPUID_EXT3_SVM | CPUID_EXT3_LAHF_LM,
 727         .xlevel = 0x80000008,
 728         .model_id = "AMD Opteron 22xx (Gen 2 Class Opteron)",
 729     },
 730     {
 731         .name = "Opteron_G3",
 732         .level = 5,
 733         .vendor1 = CPUID_VENDOR_AMD_1,
 734         .vendor2 = CPUID_VENDOR_AMD_2,
 735         .vendor3 = CPUID_VENDOR_AMD_3,
 736         .family = 15,
 737         .model = 6,
 738         .stepping = 1,
 739         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 740              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 741              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 742              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 743              CPUID_DE | CPUID_FP87,
 744         .ext_features = CPUID_EXT_POPCNT | CPUID_EXT_CX16 | CPUID_EXT_MONITOR |
 745              CPUID_EXT_SSE3,
 746         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_RDTSCP | CPUID_EXT2_FXSR |
 747              CPUID_EXT2_MMX | CPUID_EXT2_NX | CPUID_EXT2_PSE36 |
 748              CPUID_EXT2_PAT | CPUID_EXT2_CMOV | CPUID_EXT2_MCA |
 749              CPUID_EXT2_PGE | CPUID_EXT2_MTRR | CPUID_EXT2_SYSCALL |
 750              CPUID_EXT2_APIC | CPUID_EXT2_CX8 | CPUID_EXT2_MCE |
 751              CPUID_EXT2_PAE | CPUID_EXT2_MSR | CPUID_EXT2_TSC | CPUID_EXT2_PSE |
 752              CPUID_EXT2_DE | CPUID_EXT2_FPU,
 753         .ext3_features = CPUID_EXT3_MISALIGNSSE | CPUID_EXT3_SSE4A |
 754              CPUID_EXT3_ABM | CPUID_EXT3_SVM | CPUID_EXT3_LAHF_LM,
 755         .xlevel = 0x80000008,
 756         .model_id = "AMD Opteron 23xx (Gen 3 Class Opteron)",
 757     },
 758     {
 759         .name = "Opteron_G4",
 760         .level = 0xd,
 761         .vendor1 = CPUID_VENDOR_AMD_1,
 762         .vendor2 = CPUID_VENDOR_AMD_2,
 763         .vendor3 = CPUID_VENDOR_AMD_3,
 764         .family = 21,
 765         .model = 1,
 766         .stepping = 2,
 767         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 768              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 769              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 770              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 771              CPUID_DE | CPUID_FP87,
 772         .ext_features = CPUID_EXT_AVX | CPUID_EXT_XSAVE | CPUID_EXT_AES |
 773              CPUID_EXT_POPCNT | CPUID_EXT_SSE42 | CPUID_EXT_SSE41 |
 774              CPUID_EXT_CX16 | CPUID_EXT_SSSE3 | CPUID_EXT_PCLMULQDQ |
 775              CPUID_EXT_SSE3,
 776         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_RDTSCP |
 777              CPUID_EXT2_PDPE1GB | CPUID_EXT2_FXSR | CPUID_EXT2_MMX |
 778              CPUID_EXT2_NX | CPUID_EXT2_PSE36 | CPUID_EXT2_PAT |
 779              CPUID_EXT2_CMOV | CPUID_EXT2_MCA | CPUID_EXT2_PGE |
 780              CPUID_EXT2_MTRR | CPUID_EXT2_SYSCALL | CPUID_EXT2_APIC |
 781              CPUID_EXT2_CX8 | CPUID_EXT2_MCE | CPUID_EXT2_PAE | CPUID_EXT2_MSR |
 782              CPUID_EXT2_TSC | CPUID_EXT2_PSE | CPUID_EXT2_DE | CPUID_EXT2_FPU,
 783         .ext3_features = CPUID_EXT3_FMA4 | CPUID_EXT3_XOP |
 784              CPUID_EXT3_3DNOWPREFETCH | CPUID_EXT3_MISALIGNSSE |
 785              CPUID_EXT3_SSE4A | CPUID_EXT3_ABM | CPUID_EXT3_SVM |
 786              CPUID_EXT3_LAHF_LM,
 787         .xlevel = 0x8000001A,
 788         .model_id = "AMD Opteron 62xx class CPU",
 789     },
 790     {
 791         .name = "Opteron_G5",
 792         .level = 0xd,
 793         .vendor1 = CPUID_VENDOR_AMD_1,
 794         .vendor2 = CPUID_VENDOR_AMD_2,
 795         .vendor3 = CPUID_VENDOR_AMD_3,
 796         .family = 21,
 797         .model = 2,
 798         .stepping = 0,
 799         .features = CPUID_SSE2 | CPUID_SSE | CPUID_FXSR | CPUID_MMX |
 800              CPUID_CLFLUSH | CPUID_PSE36 | CPUID_PAT | CPUID_CMOV | CPUID_MCA |
 801              CPUID_PGE | CPUID_MTRR | CPUID_SEP | CPUID_APIC | CPUID_CX8 |
 802              CPUID_MCE | CPUID_PAE | CPUID_MSR | CPUID_TSC | CPUID_PSE |
 803              CPUID_DE | CPUID_FP87,
 804         .ext_features = CPUID_EXT_F16C | CPUID_EXT_AVX | CPUID_EXT_XSAVE |
 805              CPUID_EXT_AES | CPUID_EXT_POPCNT | CPUID_EXT_SSE42 |
 806              CPUID_EXT_SSE41 | CPUID_EXT_CX16 | CPUID_EXT_FMA |
 807              CPUID_EXT_SSSE3 | CPUID_EXT_PCLMULQDQ | CPUID_EXT_SSE3,
 808         .ext2_features = CPUID_EXT2_LM | CPUID_EXT2_RDTSCP |
 809              CPUID_EXT2_PDPE1GB | CPUID_EXT2_FXSR | CPUID_EXT2_MMX |
 810              CPUID_EXT2_NX | CPUID_EXT2_PSE36 | CPUID_EXT2_PAT |
 811              CPUID_EXT2_CMOV | CPUID_EXT2_MCA | CPUID_EXT2_PGE |
 812              CPUID_EXT2_MTRR | CPUID_EXT2_SYSCALL | CPUID_EXT2_APIC |
 813              CPUID_EXT2_CX8 | CPUID_EXT2_MCE | CPUID_EXT2_PAE | CPUID_EXT2_MSR |
 814              CPUID_EXT2_TSC | CPUID_EXT2_PSE | CPUID_EXT2_DE | CPUID_EXT2_FPU,
 815         .ext3_features = CPUID_EXT3_TBM | CPUID_EXT3_FMA4 | CPUID_EXT3_XOP |
 816              CPUID_EXT3_3DNOWPREFETCH | CPUID_EXT3_MISALIGNSSE |
 817              CPUID_EXT3_SSE4A | CPUID_EXT3_ABM | CPUID_EXT3_SVM |
 818              CPUID_EXT3_LAHF_LM,
 819         .xlevel = 0x8000001A,
 820         .model_id = "AMD Opteron 63xx class CPU",
 821     },
 822 };
 823
 824 #ifdef CONFIG_KVM
 825 static int cpu_x86_fill_model_id(char *str)
 826 {
 827     uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
 828     int i;
 829
 830     for (i = 0; i < 3; i++) {
 831         host_cpuid(0x80000002 + i, 0, &eax, &ebx, &ecx, &edx);
 832         memcpy(str + i * 16 +  0, &eax, 4);
 833         memcpy(str + i * 16 +  4, &ebx, 4);
 834         memcpy(str + i * 16 +  8, &ecx, 4);
 835         memcpy(str + i * 16 + 12, &edx, 4);
 836     }
 837     return 0;
 838 }
 839 #endif
 840
 841 /* Fill a x86_def_t struct with information about the host CPU, and
 842  * the CPU features supported by the host hardware + host kernel
 843  *
 844  * This function may be called only if KVM is enabled.
 845  */
 846 static void kvm_cpu_fill_host(x86_def_t *x86_cpu_def)
 847 {
 848 #ifdef CONFIG_KVM
 849     KVMState *s = kvm_state;
 850     uint32_t eax = 0, ebx = 0, ecx = 0, edx = 0;
 851
 852     assert(kvm_enabled());
 853
 854     x86_cpu_def->name = "host";
 855     host_cpuid(0x0, 0, &eax, &ebx, &ecx, &edx);
 856     x86_cpu_def->vendor1 = ebx;
 857     x86_cpu_def->vendor2 = edx;
 858     x86_cpu_def->vendor3 = ecx;
 859
 860     host_cpuid(0x1, 0, &eax, &ebx, &ecx, &edx);
 861     x86_cpu_def->family = ((eax >> 8) & 0x0F) + ((eax >> 20) & 0xFF);
 862     x86_cpu_def->model = ((eax >> 4) & 0x0F) | ((eax & 0xF0000) >> 12);
 863     x86_cpu_def->stepping = eax & 0x0F;
 864
 865     x86_cpu_def->level = kvm_arch_get_supported_cpuid(s, 0x0, 0, R_EAX);
 866     x86_cpu_def->features = kvm_arch_get_supported_cpuid(s, 0x1, 0, R_EDX);
 867     x86_cpu_def->ext_features = kvm_arch_get_supported_cpuid(s, 0x1, 0, R_ECX);
 868
 869     if (x86_cpu_def->level >= 7) {
 870         x86_cpu_def->cpuid_7_0_ebx_features =
 871                     kvm_arch_get_supported_cpuid(s, 0x7, 0, R_EBX);
 872     } else {
 873         x86_cpu_def->cpuid_7_0_ebx_features = 0;
 874     }
 875
 876     x86_cpu_def->xlevel = kvm_arch_get_supported_cpuid(s, 0x80000000, 0, R_EAX);
 877     x86_cpu_def->ext2_features =
 878                 kvm_arch_get_supported_cpuid(s, 0x80000001, 0, R_EDX);
 879     x86_cpu_def->ext3_features =
 880                 kvm_arch_get_supported_cpuid(s, 0x80000001, 0, R_ECX);
 881
 882     cpu_x86_fill_model_id(x86_cpu_def->model_id);
 883     x86_cpu_def->vendor_override = 0;
 884
 885     /* Call Centaur's CPUID instruction. */
 886     if (x86_cpu_def->vendor1 == CPUID_VENDOR_VIA_1 &&
 887         x86_cpu_def->vendor2 == CPUID_VENDOR_VIA_2 &&
 888         x86_cpu_def->vendor3 == CPUID_VENDOR_VIA_3) {
 889         host_cpuid(0xC0000000, 0, &eax, &ebx, &ecx, &edx);
 890         eax = kvm_arch_get_supported_cpuid(s, 0xC0000000, 0, R_EAX);
 891         if (eax >= 0xC0000001) {
 892             /* Support VIA max extended level */
 893             x86_cpu_def->xlevel2 = eax;
 894             host_cpuid(0xC0000001, 0, &eax, &ebx, &ecx, &edx);
 895             x86_cpu_def->ext4_features =
 896                     kvm_arch_get_supported_cpuid(s, 0xC0000001, 0, R_EDX);
 897         }
 898     }
 899
 900     /*
 901      * Every SVM feature requires emulation support in KVM - so we can't just
 902      * read the host features here. KVM might even support SVM features not
 903      * available on the host hardware. Just set all bits and mask out the
 904      * unsupported ones later.
 905      */
 906     x86_cpu_def->svm_features = -1;
 907 #endif /* CONFIG_KVM */
 908 }
 909
 910 static int unavailable_host_feature(struct model_features_t *f, uint32_t mask)
 911 {
 912     int i;
 913
 914     for (i = 0; i < 32; ++i)
 915         if (1 << i & mask) {
 916             fprintf(stderr, "warning: host cpuid %04x_%04x lacks requested"
 917                 " flag '%s' [0x%08x]\n",
 918                 f->cpuid >> 16, f->cpuid & 0xffff,
 919                 f->flag_names[i] ? f->flag_names[i] : "[reserved]", mask);
 920             break;
 921         }
 922     return 0;
 923 }
 924
 925 /* best effort attempt to inform user requested cpu flags aren't making
 926  * their way to the guest.  Note: ft[].check_feat ideally should be
 927  * specified via a guest_def field to suppress report of extraneous flags.
 928  *
 929  * This function may be called only if KVM is enabled.
 930  */
 931 static int kvm_check_features_against_host(x86_def_t *guest_def)
 932 {
 933     x86_def_t host_def;
 934     uint32_t mask;
 935     int rv, i;
 936     struct model_features_t ft[] = {
 937         {&guest_def->features, &host_def.features,
 938             ~0, feature_name, 0x00000000},
 939         {&guest_def->ext_features, &host_def.ext_features,
 940             ~CPUID_EXT_HYPERVISOR, ext_feature_name, 0x00000001},
 941         {&guest_def->ext2_features, &host_def.ext2_features,
 942             ~PPRO_FEATURES, ext2_feature_name, 0x80000000},
 943         {&guest_def->ext3_features, &host_def.ext3_features,
 944             ~CPUID_EXT3_SVM, ext3_feature_name, 0x80000001}};
 945
 946     assert(kvm_enabled());
 947
 948     kvm_cpu_fill_host(&host_def);
 949     for (rv = 0, i = 0; i < ARRAY_SIZE(ft); ++i)
 950         for (mask = 1; mask; mask <<= 1)
 951             if (ft[i].check_feat & mask && *ft[i].guest_feat & mask &&
 952                 !(*ft[i].host_feat & mask)) {
 953                     unavailable_host_feature(&ft[i], mask);
 954                     rv = 1;
 955                 }
 956     return rv;
 957 }
 958
 959 static void x86_cpuid_version_get_family(Object *obj, Visitor *v, void *opaque,
 960                                          const char *name, Error **errp)
 961 {
 962     X86CPU *cpu = X86_CPU(obj);
 963     CPUX86State *env = &cpu->env;
 964     int64_t value;
 965
 966     value = (env->cpuid_version >> 8) & 0xf;
 967     if (value == 0xf) {
 968         value += (env->cpuid_version >> 20) & 0xff;
 969     }
 970     visit_type_int(v, &value, name, errp);
 971 }
 972
 973 static void x86_cpuid_version_set_family(Object *obj, Visitor *v, void *opaque,
 974                                          const char *name, Error **errp)
 975 {
 976     X86CPU *cpu = X86_CPU(obj);
 977     CPUX86State *env = &cpu->env;
 978     const int64_t min = 0;
 979     const int64_t max = 0xff + 0xf;
 980     int64_t value;
 981
 982     visit_type_int(v, &value, name, errp);
 983     if (error_is_set(errp)) {
 984         return;
 985     }
 986     if (value < min || value > max) {
 987         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
 988                   name ? name : "null", value, min, max);
 989         return;
 990     }
 991
 992     env->cpuid_version &= ~0xff00f00;
 993     if (value > 0x0f) {
 994         env->cpuid_version |= 0xf00 | ((value - 0x0f) << 20);
 995     } else {
 996         env->cpuid_version |= value << 8;
 997     }
 998 }
 999
1000 static void x86_cpuid_version_get_model(Object *obj, Visitor *v, void *opaque,
1001                                         const char *name, Error **errp)
1002 {
1003     X86CPU *cpu = X86_CPU(obj);
1004     CPUX86State *env = &cpu->env;
1005     int64_t value;
1006
1007     value = (env->cpuid_version >> 4) & 0xf;
1008     value |= ((env->cpuid_version >> 16) & 0xf) << 4;
1009     visit_type_int(v, &value, name, errp);
1010 }
1011
1012 static void x86_cpuid_version_set_model(Object *obj, Visitor *v, void *opaque,
1013                                         const char *name, Error **errp)
1014 {
1015     X86CPU *cpu = X86_CPU(obj);
1016     CPUX86State *env = &cpu->env;
1017     const int64_t min = 0;
1018     const int64_t max = 0xff;
1019     int64_t value;
1020
1021     visit_type_int(v, &value, name, errp);
1022     if (error_is_set(errp)) {
1023         return;
1024     }
1025     if (value < min || value > max) {
1026         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
1027                   name ? name : "null", value, min, max);
1028         return;
1029     }
1030
1031     env->cpuid_version &= ~0xf00f0;
1032     env->cpuid_version |= ((value & 0xf) << 4) | ((value >> 4) << 16);
1033 }
1034
1035 static void x86_cpuid_version_get_stepping(Object *obj, Visitor *v,
1036                                            void *opaque, const char *name,
1037                                            Error **errp)
1038 {
1039     X86CPU *cpu = X86_CPU(obj);
1040     CPUX86State *env = &cpu->env;
1041     int64_t value;
1042
1043     value = env->cpuid_version & 0xf;
1044     visit_type_int(v, &value, name, errp);
1045 }
1046
1047 static void x86_cpuid_version_set_stepping(Object *obj, Visitor *v,
1048                                            void *opaque, const char *name,
1049                                            Error **errp)
1050 {
1051     X86CPU *cpu = X86_CPU(obj);
1052     CPUX86State *env = &cpu->env;
1053     const int64_t min = 0;
1054     const int64_t max = 0xf;
1055     int64_t value;
1056
1057     visit_type_int(v, &value, name, errp);
1058     if (error_is_set(errp)) {
1059         return;
1060     }
1061     if (value < min || value > max) {
1062         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
1063                   name ? name : "null", value, min, max);
1064         return;
1065     }
1066
1067     env->cpuid_version &= ~0xf;
1068     env->cpuid_version |= value & 0xf;
1069 }
1070
1071 static void x86_cpuid_get_level(Object *obj, Visitor *v, void *opaque,
1072                                 const char *name, Error **errp)
1073 {
1074     X86CPU *cpu = X86_CPU(obj);
1075
1076     visit_type_uint32(v, &cpu->env.cpuid_level, name, errp);
1077 }
1078
1079 static void x86_cpuid_set_level(Object *obj, Visitor *v, void *opaque,
1080                                 const char *name, Error **errp)
1081 {
1082     X86CPU *cpu = X86_CPU(obj);
1083
1084     visit_type_uint32(v, &cpu->env.cpuid_level, name, errp);
1085 }
1086
1087 static void x86_cpuid_get_xlevel(Object *obj, Visitor *v, void *opaque,
1088                                  const char *name, Error **errp)
1089 {
1090     X86CPU *cpu = X86_CPU(obj);
1091
1092     visit_type_uint32(v, &cpu->env.cpuid_xlevel, name, errp);
1093 }
1094
1095 static void x86_cpuid_set_xlevel(Object *obj, Visitor *v, void *opaque,
1096                                  const char *name, Error **errp)
1097 {
1098     X86CPU *cpu = X86_CPU(obj);
1099
1100     visit_type_uint32(v, &cpu->env.cpuid_xlevel, name, errp);
1101 }
1102
1103 static char *x86_cpuid_get_vendor(Object *obj, Error **errp)
1104 {
1105     X86CPU *cpu = X86_CPU(obj);
1106     CPUX86State *env = &cpu->env;
1107     char *value;
1108     int i;
1109
1110     value = (char *)g_malloc(CPUID_VENDOR_SZ + 1);
1111     for (i = 0; i < 4; i++) {
1112         value[i    ] = env->cpuid_vendor1 >> (8 * i);
1113         value[i + 4] = env->cpuid_vendor2 >> (8 * i);
1114         value[i + 8] = env->cpuid_vendor3 >> (8 * i);
1115     }
1116     value[CPUID_VENDOR_SZ] = '\0';
1117     return value;
1118 }
1119
1120 static void x86_cpuid_set_vendor(Object *obj, const char *value,
1121                                  Error **errp)
1122 {
1123     X86CPU *cpu = X86_CPU(obj);
1124     CPUX86State *env = &cpu->env;
1125     int i;
1126
1127     if (strlen(value) != CPUID_VENDOR_SZ) {
1128         error_set(errp, QERR_PROPERTY_VALUE_BAD, "",
1129                   "vendor", value);
1130         return;
1131     }
1132
1133     env->cpuid_vendor1 = 0;
1134     env->cpuid_vendor2 = 0;
1135     env->cpuid_vendor3 = 0;
1136     for (i = 0; i < 4; i++) {
1137         env->cpuid_vendor1 |= ((uint8_t)value[i    ]) << (8 * i);
1138         env->cpuid_vendor2 |= ((uint8_t)value[i + 4]) << (8 * i);
1139         env->cpuid_vendor3 |= ((uint8_t)value[i + 8]) << (8 * i);
1140     }
1141     env->cpuid_vendor_override = 1;
1142 }
1143
1144 static char *x86_cpuid_get_model_id(Object *obj, Error **errp)
1145 {
1146     X86CPU *cpu = X86_CPU(obj);
1147     CPUX86State *env = &cpu->env;
1148     char *value;
1149     int i;
1150
1151     value = g_malloc(48 + 1);
1152     for (i = 0; i < 48; i++) {
1153         value[i] = env->cpuid_model[i >> 2] >> (8 * (i & 3));
1154     }
1155     value[48] = '\0';
1156     return value;
1157 }
1158
1159 static void x86_cpuid_set_model_id(Object *obj, const char *model_id,
1160                                    Error **errp)
1161 {
1162     X86CPU *cpu = X86_CPU(obj);
1163     CPUX86State *env = &cpu->env;
1164     int c, len, i;
1165
1166     if (model_id == NULL) {
1167         model_id = "";
1168     }
1169     len = strlen(model_id);
1170     memset(env->cpuid_model, 0, 48);
1171     for (i = 0; i < 48; i++) {
1172         if (i >= len) {
1173             c = '\0';
1174         } else {
1175             c = (uint8_t)model_id[i];
1176         }
1177         env->cpuid_model[i >> 2] |= c << (8 * (i & 3));
1178     }
1179 }
1180
1181 static void x86_cpuid_get_tsc_freq(Object *obj, Visitor *v, void *opaque,
1182                                    const char *name, Error **errp)
1183 {
1184     X86CPU *cpu = X86_CPU(obj);
1185     int64_t value;
1186
1187     value = cpu->env.tsc_khz * 1000;
1188     visit_type_int(v, &value, name, errp);
1189 }
1190
1191 static void x86_cpuid_set_tsc_freq(Object *obj, Visitor *v, void *opaque,
1192                                    const char *name, Error **errp)
1193 {
1194     X86CPU *cpu = X86_CPU(obj);
1195     const int64_t min = 0;
1196     const int64_t max = INT64_MAX;
1197     int64_t value;
1198
1199     visit_type_int(v, &value, name, errp);
1200     if (error_is_set(errp)) {
1201         return;
1202     }
1203     if (value < min || value > max) {
1204         error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, "",
1205                   name ? name : "null", value, min, max);
1206         return;
1207     }
1208
1209     cpu->env.tsc_khz = value / 1000;
1210 }
1211
1212 static int cpu_x86_find_by_name(x86_def_t *x86_cpu_def, const char *name)
1213 {
1214     x86_def_t *def;
1215
1216     for (def = x86_defs; def; def = def->next) {
1217         if (name && !strcmp(name, def->name)) {
1218             break;
1219         }
1220     }
1221     if (kvm_enabled() && name && strcmp(name, "host") == 0) {
1222         kvm_cpu_fill_host(x86_cpu_def);
1223     } else if (!def) {
1224         return -1;
1225     } else {
1226         memcpy(x86_cpu_def, def, sizeof(*def));
1227     }
1228
1229     return 0;
1230 }
1231
1232 /* Parse "+feature,-feature,feature=foo" CPU feature string
1233  */
1234 static int cpu_x86_parse_featurestr(x86_def_t *x86_cpu_def, char *features)
1235 {
1236     unsigned int i;
1237     char *featurestr; /* Single 'key=value" string being parsed */
1238     /* Features to be added */
1239     uint32_t plus_features = 0, plus_ext_features = 0;
1240     uint32_t plus_ext2_features = 0, plus_ext3_features = 0;
1241     uint32_t plus_kvm_features = kvm_default_features, plus_svm_features = 0;
1242     uint32_t plus_7_0_ebx_features = 0;
1243     /* Features to be removed */
1244     uint32_t minus_features = 0, minus_ext_features = 0;
1245     uint32_t minus_ext2_features = 0, minus_ext3_features = 0;
1246     uint32_t minus_kvm_features = 0, minus_svm_features = 0;
1247     uint32_t minus_7_0_ebx_features = 0;
1248     uint32_t numvalue;
1249
1250     add_flagname_to_bitmaps("hypervisor", &plus_features,
1251             &plus_ext_features, &plus_ext2_features, &plus_ext3_features,
1252             &plus_kvm_features, &plus_svm_features,  &plus_7_0_ebx_features);
1253
1254     featurestr = features ? strtok(features, ",") : NULL;
1255
1256     while (featurestr) {
1257         char *val;
1258         if (featurestr[0] == '+') {
1259             add_flagname_to_bitmaps(featurestr + 1, &plus_features,
1260                             &plus_ext_features, &plus_ext2_features,
1261                             &plus_ext3_features, &plus_kvm_features,
1262                             &plus_svm_features, &plus_7_0_ebx_features);
1263         } else if (featurestr[0] == '-') {
1264             add_flagname_to_bitmaps(featurestr + 1, &minus_features,
1265                             &minus_ext_features, &minus_ext2_features,
1266                             &minus_ext3_features, &minus_kvm_features,
1267                             &minus_svm_features, &minus_7_0_ebx_features);
1268         } else if ((val = strchr(featurestr, '='))) {
1269             *val = 0; val++;
1270             if (!strcmp(featurestr, "family")) {
1271                 char *err;
1272                 numvalue = strtoul(val, &err, 0);
1273                 if (!*val || *err || numvalue > 0xff + 0xf) {
1274                     fprintf(stderr, "bad numerical value %s\n", val);
1275                     goto error;
1276                 }
1277                 x86_cpu_def->family = numvalue;
1278             } else if (!strcmp(featurestr, "model")) {
1279                 char *err;
1280                 numvalue = strtoul(val, &err, 0);
1281                 if (!*val || *err || numvalue > 0xff) {
1282                     fprintf(stderr, "bad numerical value %s\n", val);
1283                     goto error;
1284                 }
1285                 x86_cpu_def->model = numvalue;
1286             } else if (!strcmp(featurestr, "stepping")) {
1287                 char *err;
1288                 numvalue = strtoul(val, &err, 0);
1289                 if (!*val || *err || numvalue > 0xf) {
1290                     fprintf(stderr, "bad numerical value %s\n", val);
1291                     goto error;
1292                 }
1293                 x86_cpu_def->stepping = numvalue ;
1294             } else if (!strcmp(featurestr, "level")) {
1295                 char *err;
1296                 numvalue = strtoul(val, &err, 0);
1297                 if (!*val || *err) {
1298                     fprintf(stderr, "bad numerical value %s\n", val);
1299                     goto error;
1300                 }
1301                 x86_cpu_def->level = numvalue;
1302             } else if (!strcmp(featurestr, "xlevel")) {
1303                 char *err;
1304                 numvalue = strtoul(val, &err, 0);
1305                 if (!*val || *err) {
1306                     fprintf(stderr, "bad numerical value %s\n", val);
1307                     goto error;
1308                 }
1309                 if (numvalue < 0x80000000) {
1310                     numvalue += 0x80000000;
1311                 }
1312                 x86_cpu_def->xlevel = numvalue;
1313             } else if (!strcmp(featurestr, "vendor")) {
1314                 if (strlen(val) != 12) {
1315                     fprintf(stderr, "vendor string must be 12 chars long\n");
1316                     goto error;
1317                 }
1318                 x86_cpu_def->vendor1 = 0;
1319                 x86_cpu_def->vendor2 = 0;
1320                 x86_cpu_def->vendor3 = 0;
1321                 for(i = 0; i < 4; i++) {
1322                     x86_cpu_def->vendor1 |= ((uint8_t)val[i    ]) << (8 * i);
1323                     x86_cpu_def->vendor2 |= ((uint8_t)val[i + 4]) << (8 * i);
1324                     x86_cpu_def->vendor3 |= ((uint8_t)val[i + 8]) << (8 * i);
1325                 }
1326                 x86_cpu_def->vendor_override = 1;
1327             } else if (!strcmp(featurestr, "model_id")) {
1328                 pstrcpy(x86_cpu_def->model_id, sizeof(x86_cpu_def->model_id),
1329                         val);
1330             } else if (!strcmp(featurestr, "tsc_freq")) {
1331                 int64_t tsc_freq;
1332                 char *err;
1333
1334                 tsc_freq = strtosz_suffix_unit(val, &err,
1335                                                STRTOSZ_DEFSUFFIX_B, 1000);
1336                 if (tsc_freq < 0 || *err) {
1337                     fprintf(stderr, "bad numerical value %s\n", val);
1338                     goto error;
1339                 }
1340                 x86_cpu_def->tsc_khz = tsc_freq / 1000;
1341             } else if (!strcmp(featurestr, "hv_spinlocks")) {
1342                 char *err;
1343                 numvalue = strtoul(val, &err, 0);
1344                 if (!*val || *err) {
1345                     fprintf(stderr, "bad numerical value %s\n", val);
1346                     goto error;
1347                 }
1348                 hyperv_set_spinlock_retries(numvalue);
1349             } else {
1350                 fprintf(stderr, "unrecognized feature %s\n", featurestr);
1351                 goto error;
1352             }
1353         } else if (!strcmp(featurestr, "check")) {
1354             check_cpuid = 1;
1355         } else if (!strcmp(featurestr, "enforce")) {
1356             check_cpuid = enforce_cpuid = 1;
1357         } else if (!strcmp(featurestr, "hv_relaxed")) {
1358             hyperv_enable_relaxed_timing(true);
1359         } else if (!strcmp(featurestr, "hv_vapic")) {
1360             hyperv_enable_vapic_recommended(true);
1361         } else {
1362             fprintf(stderr, "feature string `%s' not in format (+feature|-feature|feature=xyz)\n", featurestr);
1363             goto error;
1364         }
1365         featurestr = strtok(NULL, ",");
1366     }
1367     x86_cpu_def->features |= plus_features;
1368     x86_cpu_def->ext_features |= plus_ext_features;
1369     x86_cpu_def->ext2_features |= plus_ext2_features;
1370     x86_cpu_def->ext3_features |= plus_ext3_features;
1371     x86_cpu_def->kvm_features |= plus_kvm_features;
1372     x86_cpu_def->svm_features |= plus_svm_features;
1373     x86_cpu_def->cpuid_7_0_ebx_features |= plus_7_0_ebx_features;
1374     x86_cpu_def->features &= ~minus_features;
1375     x86_cpu_def->ext_features &= ~minus_ext_features;
1376     x86_cpu_def->ext2_features &= ~minus_ext2_features;
1377     x86_cpu_def->ext3_features &= ~minus_ext3_features;
1378     x86_cpu_def->kvm_features &= ~minus_kvm_features;
1379     x86_cpu_def->svm_features &= ~minus_svm_features;
1380     x86_cpu_def->cpuid_7_0_ebx_features &= ~minus_7_0_ebx_features;
1381     if (check_cpuid && kvm_enabled()) {
1382         if (kvm_check_features_against_host(x86_cpu_def) && enforce_cpuid)
1383             goto error;
1384     }
1385     return 0;
1386
1387 error:
1388     return -1;
1389 }
1390
1391 /* generate a composite string into buf of all cpuid names in featureset
1392  * selected by fbits.  indicate truncation at bufsize in the event of overflow.
1393  * if flags, suppress names undefined in featureset.
1394  */
1395 static void listflags(char *buf, int bufsize, uint32_t fbits,
1396     const char **featureset, uint32_t flags)
1397 {
1398     const char **p = &featureset[31];
1399     char *q, *b, bit;
1400     int nc;
1401
1402     b = 4 <= bufsize ? buf + (bufsize -= 3) - 1 : NULL;
1403     *buf = '\0';
1404     for (q = buf, bit = 31; fbits && bufsize; --p, fbits &= ~(1 << bit), --bit)
1405         if (fbits & 1 << bit && (*p || !flags)) {
1406             if (*p)
1407                 nc = snprintf(q, bufsize, "%s%s", q == buf ? "" : " ", *p);
1408             else
1409                 nc = snprintf(q, bufsize, "%s[%d]", q == buf ? "" : " ", bit);
1410             if (bufsize <= nc) {
1411                 if (b) {
1412                     memcpy(b, "...", sizeof("..."));
1413                 }
1414                 return;
1415             }
1416             q += nc;
1417             bufsize -= nc;
1418         }
1419 }
1420
1421 /* generate CPU information. */
1422 void x86_cpu_list(FILE *f, fprintf_function cpu_fprintf)
1423 {
1424     x86_def_t *def;
1425     char buf[256];
1426
1427     for (def = x86_defs; def; def = def->next) {
1428         snprintf(buf, sizeof(buf), "%s", def->name);
1429         (*cpu_fprintf)(f, "x86 %16s  %-48s\n", buf, def->model_id);
1430     }
1431     if (kvm_enabled()) {
1432         (*cpu_fprintf)(f, "x86 %16s\n", "[host]");
1433     }
1434     (*cpu_fprintf)(f, "\nRecognized CPUID flags:\n");
1435     listflags(buf, sizeof(buf), (uint32_t)~0, feature_name, 1);
1436     (*cpu_fprintf)(f, "  %s\n", buf);
1437     listflags(buf, sizeof(buf), (uint32_t)~0, ext_feature_name, 1);
1438     (*cpu_fprintf)(f, "  %s\n", buf);
1439     listflags(buf, sizeof(buf), (uint32_t)~0, ext2_feature_name, 1);
1440     (*cpu_fprintf)(f, "  %s\n", buf);
1441     listflags(buf, sizeof(buf), (uint32_t)~0, ext3_feature_name, 1);
1442     (*cpu_fprintf)(f, "  %s\n", buf);
1443 }
1444
1445 CpuDefinitionInfoList *arch_query_cpu_definitions(Error **errp)
1446 {
1447     CpuDefinitionInfoList *cpu_list = NULL;
1448     x86_def_t *def;
1449
1450     for (def = x86_defs; def; def = def->next) {
1451         CpuDefinitionInfoList *entry;
1452         CpuDefinitionInfo *info;
1453
1454         info = g_malloc0(sizeof(*info));
1455         info->name = g_strdup(def->name);
1456
1457         entry = g_malloc0(sizeof(*entry));
1458         entry->value = info;
1459         entry->next = cpu_list;
1460         cpu_list = entry;
1461     }
1462
1463     return cpu_list;
1464 }
1465
1466 #ifdef CONFIG_KVM
1467 static void filter_features_for_kvm(X86CPU *cpu)
1468 {
1469     CPUX86State *env = &cpu->env;
1470     KVMState *s = kvm_state;
1471
1472     env->cpuid_features &=
1473         kvm_arch_get_supported_cpuid(s, 1, 0, R_EDX);
1474     env->cpuid_ext_features &=
1475         kvm_arch_get_supported_cpuid(s, 1, 0, R_ECX);
1476     env->cpuid_ext2_features &=
1477         kvm_arch_get_supported_cpuid(s, 0x80000001, 0, R_EDX);
1478     env->cpuid_ext3_features &=
1479         kvm_arch_get_supported_cpuid(s, 0x80000001, 0, R_ECX);
1480     env->cpuid_svm_features  &=
1481         kvm_arch_get_supported_cpuid(s, 0x8000000A, 0, R_EDX);
1482     env->cpuid_7_0_ebx_features &=
1483         kvm_arch_get_supported_cpuid(s, 7, 0, R_EBX);
1484     env->cpuid_kvm_features &=
1485         kvm_arch_get_supported_cpuid(s, KVM_CPUID_FEATURES, 0, R_EAX);
1486     env->cpuid_ext4_features &=
1487         kvm_arch_get_supported_cpuid(s, 0xC0000001, 0, R_EDX);
1488
1489 }
1490 #endif
1491
1492 int cpu_x86_register(X86CPU *cpu, const char *cpu_model)
1493 {
1494     CPUX86State *env = &cpu->env;
1495     x86_def_t def1, *def = &def1;
1496     Error *error = NULL;
1497     char *name, *features;
1498     gchar **model_pieces;
1499
1500     memset(def, 0, sizeof(*def));
1501
1502     model_pieces = g_strsplit(cpu_model, ",", 2);
1503     if (!model_pieces[0]) {
1504         goto error;
1505     }
1506     name = model_pieces[0];
1507     features = model_pieces[1];
1508
1509     if (cpu_x86_find_by_name(def, name) < 0) {
1510         goto error;
1511     }
1512
1513     if (cpu_x86_parse_featurestr(def, features) < 0) {
1514         goto error;
1515     }
1516     if (def->vendor1) {
1517         env->cpuid_vendor1 = def->vendor1;
1518         env->cpuid_vendor2 = def->vendor2;
1519         env->cpuid_vendor3 = def->vendor3;
1520     } else {
1521         env->cpuid_vendor1 = CPUID_VENDOR_INTEL_1;
1522         env->cpuid_vendor2 = CPUID_VENDOR_INTEL_2;
1523         env->cpuid_vendor3 = CPUID_VENDOR_INTEL_3;
1524     }
1525     env->cpuid_vendor_override = def->vendor_override;
1526     object_property_set_int(OBJECT(cpu), def->level, "level", &error);
1527     object_property_set_int(OBJECT(cpu), def->family, "family", &error);
1528     object_property_set_int(OBJECT(cpu), def->model, "model", &error);
1529     object_property_set_int(OBJECT(cpu), def->stepping, "stepping", &error);
1530     env->cpuid_features = def->features;
1531     env->cpuid_ext_features = def->ext_features;
1532     env->cpuid_ext2_features = def->ext2_features;
1533     env->cpuid_ext3_features = def->ext3_features;
1534     object_property_set_int(OBJECT(cpu), def->xlevel, "xlevel", &error);
1535     env->cpuid_kvm_features = def->kvm_features;
1536     env->cpuid_svm_features = def->svm_features;
1537     env->cpuid_ext4_features = def->ext4_features;
1538     env->cpuid_7_0_ebx_features = def->cpuid_7_0_ebx_features;
1539     env->cpuid_xlevel2 = def->xlevel2;
1540     object_property_set_int(OBJECT(cpu), (int64_t)def->tsc_khz * 1000,
1541                             "tsc-frequency", &error);
1542
1543     /* On AMD CPUs, some CPUID[8000_0001].EDX bits must match the bits on
1544      * CPUID[1].EDX.
1545      */
1546     if (env->cpuid_vendor1 == CPUID_VENDOR_AMD_1 &&
1547             env->cpuid_vendor2 == CPUID_VENDOR_AMD_2 &&
1548             env->cpuid_vendor3 == CPUID_VENDOR_AMD_3) {
1549         env->cpuid_ext2_features &= ~CPUID_EXT2_AMD_ALIASES;
1550         env->cpuid_ext2_features |= (def->features & CPUID_EXT2_AMD_ALIASES);
1551     }
1552
1553     if (!kvm_enabled()) {
1554         env->cpuid_features &= TCG_FEATURES;
1555         env->cpuid_ext_features &= TCG_EXT_FEATURES;
1556         env->cpuid_ext2_features &= (TCG_EXT2_FEATURES
1557 #ifdef TARGET_X86_64
1558             | CPUID_EXT2_SYSCALL | CPUID_EXT2_LM
1559 #endif
1560             );
1561         env->cpuid_ext3_features &= TCG_EXT3_FEATURES;
1562         env->cpuid_svm_features &= TCG_SVM_FEATURES;
1563     } else {
1564 #ifdef CONFIG_KVM
1565         filter_features_for_kvm(cpu);
1566 #endif
1567     }
1568     object_property_set_str(OBJECT(cpu), def->model_id, "model-id", &error);
1569     if (error) {
1570         fprintf(stderr, "%s\n", error_get_pretty(error));
1571         error_free(error);
1572         goto error;
1573     }
1574
1575     g_strfreev(model_pieces);
1576     return 0;
1577 error:
1578     g_strfreev(model_pieces);
1579     return -1;
1580 }
1581
1582 #if !defined(CONFIG_USER_ONLY)
1583
1584 void cpu_clear_apic_feature(CPUX86State *env)
1585 {
1586     env->cpuid_features &= ~CPUID_APIC;
1587 }
1588
1589 #endif /* !CONFIG_USER_ONLY */
1590
1591 /* Initialize list of CPU models, filling some non-static fields if necessary
1592  */
1593 void x86_cpudef_setup(void)
1594 {
1595     int i, j;
1596     static const char *model_with_versions[] = { "qemu32", "qemu64", "athlon" };
1597
1598     for (i = 0; i < ARRAY_SIZE(builtin_x86_defs); ++i) {
1599         x86_def_t *def = &builtin_x86_defs[i];
1600         def->next = x86_defs;
1601
1602         /* Look for specific "cpudef" models that */
1603         /* have the QEMU version in .model_id */
1604         for (j = 0; j < ARRAY_SIZE(model_with_versions); j++) {
1605             if (strcmp(model_with_versions[j], def->name) == 0) {
1606                 pstrcpy(def->model_id, sizeof(def->model_id),
1607                         "QEMU Virtual CPU version ");
1608                 pstrcat(def->model_id, sizeof(def->model_id),
1609                         qemu_get_version());
1610                 break;
1611             }
1612         }
1613
1614         x86_defs = def;
1615     }
1616 }
1617
1618 static void get_cpuid_vendor(CPUX86State *env, uint32_t *ebx,
1619                              uint32_t *ecx, uint32_t *edx)
1620 {
1621     *ebx = env->cpuid_vendor1;
1622     *edx = env->cpuid_vendor2;
1623     *ecx = env->cpuid_vendor3;
1624
1625     /* sysenter isn't supported on compatibility mode on AMD, syscall
1626      * isn't supported in compatibility mode on Intel.
1627      * Normally we advertise the actual cpu vendor, but you can override
1628      * this if you want to use KVM's sysenter/syscall emulation
1629      * in compatibility mode and when doing cross vendor migration
1630      */
1631     if (kvm_enabled() && ! env->cpuid_vendor_override) {
1632         host_cpuid(0, 0, NULL, ebx, ecx, edx);
1633     }
1634 }
1635
1636 void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
1637                    uint32_t *eax, uint32_t *ebx,
1638                    uint32_t *ecx, uint32_t *edx)
1639 {
1640     X86CPU *cpu = x86_env_get_cpu(env);
1641     CPUState *cs = CPU(cpu);
1642
1643     /* test if maximum index reached */
1644     if (index & 0x80000000) {
1645         if (index > env->cpuid_xlevel) {
1646             if (env->cpuid_xlevel2 > 0) {
1647                 /* Handle the Centaur's CPUID instruction. */
1648                 if (index > env->cpuid_xlevel2) {
1649                     index = env->cpuid_xlevel2;
1650                 } else if (index < 0xC0000000) {
1651                     index = env->cpuid_xlevel;
1652                 }
1653             } else {
1654                 /* Intel documentation states that invalid EAX input will
1655                  * return the same information as EAX=cpuid_level
1656                  * (Intel SDM Vol. 2A - Instruction Set Reference - CPUID)
1657                  */
1658                 index =  env->cpuid_level;
1659             }
1660         }
1661     } else {
1662         if (index > env->cpuid_level)
1663             index = env->cpuid_level;
1664     }
1665
1666     switch(index) {
1667     case 0:
1668         *eax = env->cpuid_level;
1669         get_cpuid_vendor(env, ebx, ecx, edx);
1670         break;
1671     case 1:
1672         *eax = env->cpuid_version;
1673         *ebx = (env->cpuid_apic_id << 24) | 8 << 8; /* CLFLUSH size in quad words, Linux wants it. */
1674         *ecx = env->cpuid_ext_features;
1675         *edx = env->cpuid_features;
1676         if (env->nr_cores * env->nr_threads > 1) {
1677             *ebx |= (env->nr_cores * env->nr_threads) << 16;
1678             *edx |= 1 << 28;    /* HTT bit */
1679         }
1680         break;
1681     case 2:
1682         /* cache info: needed for Pentium Pro compatibility */
1683         *eax = 1;
1684         *ebx = 0;
1685         *ecx = 0;
1686         *edx = 0x2c307d;
1687         break;
1688     case 4:
1689         /* cache info: needed for Core compatibility */
1690         if (env->nr_cores > 1) {
1691             *eax = (env->nr_cores - 1) << 26;
1692         } else {
1693             *eax = 0;
1694         }
1695         switch (count) {
1696             case 0: /* L1 dcache info */
1697                 *eax |= 0x0000121;
1698                 *ebx = 0x1c0003f;
1699                 *ecx = 0x000003f;
1700                 *edx = 0x0000001;
1701                 break;
1702             case 1: /* L1 icache info */
1703                 *eax |= 0x0000122;
1704                 *ebx = 0x1c0003f;
1705                 *ecx = 0x000003f;
1706                 *edx = 0x0000001;
1707                 break;
1708             case 2: /* L2 cache info */
1709                 *eax |= 0x0000143;
1710                 if (env->nr_threads > 1) {
1711                     *eax |= (env->nr_threads - 1) << 14;
1712                 }
1713                 *ebx = 0x3c0003f;
1714                 *ecx = 0x0000fff;
1715                 *edx = 0x0000001;
1716                 break;
1717             default: /* end of info */
1718                 *eax = 0;
1719                 *ebx = 0;
1720                 *ecx = 0;
1721                 *edx = 0;
1722                 break;
1723         }
1724         break;
1725     case 5:
1726         /* mwait info: needed for Core compatibility */
1727         *eax = 0; /* Smallest monitor-line size in bytes */
1728         *ebx = 0; /* Largest monitor-line size in bytes */
1729         *ecx = CPUID_MWAIT_EMX | CPUID_MWAIT_IBE;
1730         *edx = 0;
1731         break;
1732     case 6:
1733         /* Thermal and Power Leaf */
1734         *eax = 0;
1735         *ebx = 0;
1736         *ecx = 0;
1737         *edx = 0;
1738         break;
1739     case 7:
1740         /* Structured Extended Feature Flags Enumeration Leaf */
1741         if (count == 0) {
1742             *eax = 0; /* Maximum ECX value for sub-leaves */
1743             *ebx = env->cpuid_7_0_ebx_features; /* Feature flags */
1744             *ecx = 0; /* Reserved */
1745             *edx = 0; /* Reserved */
1746         } else {
1747             *eax = 0;
1748             *ebx = 0;
1749             *ecx = 0;
1750             *edx = 0;
1751         }
1752         break;
1753     case 9:
1754         /* Direct Cache Access Information Leaf */
1755         *eax = 0; /* Bits 0-31 in DCA_CAP MSR */
1756         *ebx = 0;
1757         *ecx = 0;
1758         *edx = 0;
1759         break;
1760     case 0xA:
1761         /* Architectural Performance Monitoring Leaf */
1762         if (kvm_enabled()) {
1763             KVMState *s = cs->kvm_state;
1764
1765             *eax = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EAX);
1766             *ebx = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EBX);
1767             *ecx = kvm_arch_get_supported_cpuid(s, 0xA, count, R_ECX);
1768             *edx = kvm_arch_get_supported_cpuid(s, 0xA, count, R_EDX);
1769         } else {
1770             *eax = 0;
1771             *ebx = 0;
1772             *ecx = 0;
1773             *edx = 0;
1774         }
1775         break;
1776     case 0xD:
1777         /* Processor Extended State */
1778         if (!(env->cpuid_ext_features & CPUID_EXT_XSAVE)) {
1779             *eax = 0;
1780             *ebx = 0;
1781             *ecx = 0;
1782             *edx = 0;
1783             break;
1784         }
1785         if (kvm_enabled()) {
1786             KVMState *s = cs->kvm_state;
1787
1788             *eax = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EAX);
1789             *ebx = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EBX);
1790             *ecx = kvm_arch_get_supported_cpuid(s, 0xd, count, R_ECX);
1791             *edx = kvm_arch_get_supported_cpuid(s, 0xd, count, R_EDX);
1792         } else {
1793             *eax = 0;
1794             *ebx = 0;
1795             *ecx = 0;
1796             *edx = 0;
1797         }
1798         break;
1799     case 0x80000000:
1800         *eax = env->cpuid_xlevel;
1801         *ebx = env->cpuid_vendor1;
1802         *edx = env->cpuid_vendor2;
1803         *ecx = env->cpuid_vendor3;
1804         break;
1805     case 0x80000001:
1806         *eax = env->cpuid_version;
1807         *ebx = 0;
1808         *ecx = env->cpuid_ext3_features;
1809         *edx = env->cpuid_ext2_features;
1810
1811         /* The Linux kernel checks for the CMPLegacy bit and
1812          * discards multiple thread information if it is set.
1813          * So dont set it here for Intel to make Linux guests happy.
1814          */
1815         if (env->nr_cores * env->nr_threads > 1) {
1816             uint32_t tebx, tecx, tedx;
1817             get_cpuid_vendor(env, &tebx, &tecx, &tedx);
1818             if (tebx != CPUID_VENDOR_INTEL_1 ||
1819                 tedx != CPUID_VENDOR_INTEL_2 ||
1820                 tecx != CPUID_VENDOR_INTEL_3) {
1821                 *ecx |= 1 << 1;    /* CmpLegacy bit */
1822             }
1823         }
1824         break;
1825     case 0x80000002:
1826     case 0x80000003:
1827     case 0x80000004:
1828         *eax = env->cpuid_model[(index - 0x80000002) * 4 + 0];
1829         *ebx = env->cpuid_model[(index - 0x80000002) * 4 + 1];
1830         *ecx = env->cpuid_model[(index - 0x80000002) * 4 + 2];
1831         *edx = env->cpuid_model[(index - 0x80000002) * 4 + 3];
1832         break;
1833     case 0x80000005:
1834         /* cache info (L1 cache) */
1835         *eax = 0x01ff01ff;
1836         *ebx = 0x01ff01ff;
1837         *ecx = 0x40020140;
1838         *edx = 0x40020140;
1839         break;
1840     case 0x80000006:
1841         /* cache info (L2 cache) */
1842         *eax = 0;
1843         *ebx = 0x42004200;
1844         *ecx = 0x02008140;
1845         *edx = 0;
1846         break;
1847     case 0x80000008:
1848         /* virtual & phys address size in low 2 bytes. */
1849 /* XXX: This value must match the one used in the MMU code. */
1850         if (env->cpuid_ext2_features & CPUID_EXT2_LM) {
1851             /* 64 bit processor */
1852 /* XXX: The physical address space is limited to 42 bits in exec.c. */
1853             *eax = 0x00003028;  /* 48 bits virtual, 40 bits physical */
1854         } else {
1855             if (env->cpuid_features & CPUID_PSE36)
1856                 *eax = 0x00000024; /* 36 bits physical */
1857             else
1858                 *eax = 0x00000020; /* 32 bits physical */
1859         }
1860         *ebx = 0;
1861         *ecx = 0;
1862         *edx = 0;
1863         if (env->nr_cores * env->nr_threads > 1) {
1864             *ecx |= (env->nr_cores * env->nr_threads) - 1;
1865         }
1866         break;
1867     case 0x8000000A:
1868         if (env->cpuid_ext3_features & CPUID_EXT3_SVM) {
1869             *eax = 0x00000001; /* SVM Revision */
1870             *ebx = 0x00000010; /* nr of ASIDs */
1871             *ecx = 0;
1872             *edx = env->cpuid_svm_features; /* optional features */
1873         } else {
1874             *eax = 0;
1875             *ebx = 0;
1876             *ecx = 0;
1877             *edx = 0;
1878         }
1879         break;
1880     case 0xC0000000:
1881         *eax = env->cpuid_xlevel2;
1882         *ebx = 0;
1883         *ecx = 0;
1884         *edx = 0;
1885         break;
1886     case 0xC0000001:
1887         /* Support for VIA CPU's CPUID instruction */
1888         *eax = env->cpuid_version;
1889         *ebx = 0;
1890         *ecx = 0;
1891         *edx = env->cpuid_ext4_features;
1892         break;
1893     case 0xC0000002:
1894     case 0xC0000003:
1895     case 0xC0000004:
1896         /* Reserved for the future, and now filled with zero */
1897         *eax = 0;
1898         *ebx = 0;
1899         *ecx = 0;
1900         *edx = 0;
1901         break;
1902     default:
1903         /* reserved values: zero */
1904         *eax = 0;
1905         *ebx = 0;
1906         *ecx = 0;
1907         *edx = 0;
1908         break;
1909     }
1910 }
1911
1912 /* CPUClass::reset() */
1913 static void x86_cpu_reset(CPUState *s)
1914 {
1915     X86CPU *cpu = X86_CPU(s);
1916     X86CPUClass *xcc = X86_CPU_GET_CLASS(cpu);
1917     CPUX86State *env = &cpu->env;
1918     int i;
1919
1920     if (qemu_loglevel_mask(CPU_LOG_RESET)) {
1921         qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
1922         log_cpu_state(env, CPU_DUMP_FPU | CPU_DUMP_CCOP);
1923     }
1924
1925     xcc->parent_reset(s);
1926
1927
1928     memset(env, 0, offsetof(CPUX86State, breakpoints));
1929
1930     tlb_flush(env, 1);
1931
1932     env->old_exception = -1;
1933
1934     /* init to reset state */
1935
1936 #ifdef CONFIG_SOFTMMU
1937     env->hflags |= HF_SOFTMMU_MASK;
1938 #endif
1939     env->hflags2 |= HF2_GIF_MASK;
1940
1941     cpu_x86_update_cr0(env, 0x60000010);
1942     env->a20_mask = ~0x0;
1943     env->smbase = 0x30000;
1944
1945     env->idt.limit = 0xffff;
1946     env->gdt.limit = 0xffff;
1947     env->ldt.limit = 0xffff;
1948     env->ldt.flags = DESC_P_MASK | (2 << DESC_TYPE_SHIFT);
1949     env->tr.limit = 0xffff;
1950     env->tr.flags = DESC_P_MASK | (11 << DESC_TYPE_SHIFT);
1951
1952     cpu_x86_load_seg_cache(env, R_CS, 0xf000, 0xffff0000, 0xffff,
1953                            DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK |
1954                            DESC_R_MASK | DESC_A_MASK);
1955     cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffff,
1956                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1957                            DESC_A_MASK);
1958     cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffff,
1959                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1960                            DESC_A_MASK);
1961     cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffff,
1962                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1963                            DESC_A_MASK);
1964     cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffff,
1965                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1966                            DESC_A_MASK);
1967     cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffff,
1968                            DESC_P_MASK | DESC_S_MASK | DESC_W_MASK |
1969                            DESC_A_MASK);
1970
1971     env->eip = 0xfff0;
1972     env->regs[R_EDX] = env->cpuid_version;
1973
1974     env->eflags = 0x2;
1975
1976     /* FPU init */
1977     for (i = 0; i < 8; i++) {
1978         env->fptags[i] = 1;
1979     }
1980     env->fpuc = 0x37f;
1981
1982     env->mxcsr = 0x1f80;
1983
1984     env->pat = 0x0007040600070406ULL;
1985     env->msr_ia32_misc_enable = MSR_IA32_MISC_ENABLE_DEFAULT;
1986
1987     memset(env->dr, 0, sizeof(env->dr));
1988     env->dr[6] = DR6_FIXED_1;
1989     env->dr[7] = DR7_FIXED_1;
1990     cpu_breakpoint_remove_all(env, BP_CPU);
1991     cpu_watchpoint_remove_all(env, BP_CPU);
1992
1993 #if !defined(CONFIG_USER_ONLY)
1994     /* We hard-wire the BSP to the first CPU. */
1995     if (env->cpu_index == 0) {
1996         apic_designate_bsp(env->apic_state);
1997     }
1998
1999     env->halted = !cpu_is_bsp(cpu);
2000 #endif
2001 }
2002
2003 #ifndef CONFIG_USER_ONLY
2004 bool cpu_is_bsp(X86CPU *cpu)
2005 {
2006     return cpu_get_apic_base(cpu->env.apic_state) & MSR_IA32_APICBASE_BSP;
2007 }
2008
2009 /* TODO: remove me, when reset over QOM tree is implemented */
2010 static void x86_cpu_machine_reset_cb(void *opaque)
2011 {
2012     X86CPU *cpu = opaque;
2013     cpu_reset(CPU(cpu));
2014 }
2015 #endif
2016
2017 static void mce_init(X86CPU *cpu)
2018 {
2019     CPUX86State *cenv = &cpu->env;
2020     unsigned int bank;
2021
2022     if (((cenv->cpuid_version >> 8) & 0xf) >= 6
2023         && (cenv->cpuid_features & (CPUID_MCE | CPUID_MCA)) ==
2024             (CPUID_MCE | CPUID_MCA)) {
2025         cenv->mcg_cap = MCE_CAP_DEF | MCE_BANKS_DEF;
2026         cenv->mcg_ctl = ~(uint64_t)0;
2027         for (bank = 0; bank < MCE_BANKS_DEF; bank++) {
2028             cenv->mce_banks[bank * 4] = ~(uint64_t)0;
2029         }
2030     }
2031 }
2032
2033 #define MSI_ADDR_BASE 0xfee00000
2034
2035 #ifndef CONFIG_USER_ONLY
2036 static void x86_cpu_apic_init(X86CPU *cpu, Error **errp)
2037 {
2038     static int apic_mapped;
2039     CPUX86State *env = &cpu->env;
2040     APICCommonState *apic;
2041     const char *apic_type = "apic";
2042
2043     if (kvm_irqchip_in_kernel()) {
2044         apic_type = "kvm-apic";
2045     } else if (xen_enabled()) {
2046         apic_type = "xen-apic";
2047     }
2048
2049     env->apic_state = qdev_try_create(NULL, apic_type);
2050     if (env->apic_state == NULL) {
2051         error_setg(errp, "APIC device '%s' could not be created", apic_type);
2052         return;
2053     }
2054
2055     object_property_add_child(OBJECT(cpu), "apic",
2056                               OBJECT(env->apic_state), NULL);
2057     qdev_prop_set_uint8(env->apic_state, "id", env->cpuid_apic_id);
2058     /* TODO: convert to link<> */
2059     apic = APIC_COMMON(env->apic_state);
2060     apic->cpu = cpu;
2061
2062     if (qdev_init(env->apic_state)) {
2063         error_setg(errp, "APIC device '%s' could not be initialized",
2064                    object_get_typename(OBJECT(env->apic_state)));
2065         return;
2066     }
2067
2068     /* XXX: mapping more APICs at the same memory location */
2069     if (apic_mapped == 0) {
2070         /* NOTE: the APIC is directly connected to the CPU - it is not
2071            on the global memory bus. */
2072         /* XXX: what if the base changes? */
2073         sysbus_mmio_map(sysbus_from_qdev(env->apic_state), 0, MSI_ADDR_BASE);
2074         apic_mapped = 1;
2075     }
2076 }
2077 #endif
2078
2079 void x86_cpu_realize(Object *obj, Error **errp)
2080 {
2081     X86CPU *cpu = X86_CPU(obj);
2082     CPUX86State *env = &cpu->env;
2083
2084     if (env->cpuid_7_0_ebx_features && env->cpuid_level < 7) {
2085         env->cpuid_level = 7;
2086     }
2087
2088 #ifndef CONFIG_USER_ONLY
2089     qemu_register_reset(x86_cpu_machine_reset_cb, cpu);
2090
2091     if (cpu->env.cpuid_features & CPUID_APIC || smp_cpus > 1) {
2092         x86_cpu_apic_init(cpu, errp);
2093         if (error_is_set(errp)) {
2094             return;
2095         }
2096     }
2097 #endif
2098
2099     mce_init(cpu);
2100     qemu_init_vcpu(&cpu->env);
2101     cpu_reset(CPU(cpu));
2102 }
2103
2104 static void x86_cpu_initfn(Object *obj)
2105 {
2106     X86CPU *cpu = X86_CPU(obj);
2107     CPUX86State *env = &cpu->env;
2108     static int inited;
2109
2110     cpu_exec_init(env);
2111
2112     object_property_add(obj, "family", "int",
2113                         x86_cpuid_version_get_family,
2114                         x86_cpuid_version_set_family, NULL, NULL, NULL);
2115     object_property_add(obj, "model", "int",
2116                         x86_cpuid_version_get_model,
2117                         x86_cpuid_version_set_model, NULL, NULL, NULL);
2118     object_property_add(obj, "stepping", "int",
2119                         x86_cpuid_version_get_stepping,
2120                         x86_cpuid_version_set_stepping, NULL, NULL, NULL);
2121     object_property_add(obj, "level", "int",
2122                         x86_cpuid_get_level,
2123                         x86_cpuid_set_level, NULL, NULL, NULL);
2124     object_property_add(obj, "xlevel", "int",
2125                         x86_cpuid_get_xlevel,
2126                         x86_cpuid_set_xlevel, NULL, NULL, NULL);
2127     object_property_add_str(obj, "vendor",
2128                             x86_cpuid_get_vendor,
2129                             x86_cpuid_set_vendor, NULL);
2130     object_property_add_str(obj, "model-id",
2131                             x86_cpuid_get_model_id,
2132                             x86_cpuid_set_model_id, NULL);
2133     object_property_add(obj, "tsc-frequency", "int",
2134                         x86_cpuid_get_tsc_freq,
2135                         x86_cpuid_set_tsc_freq, NULL, NULL, NULL);
2136
2137     env->cpuid_apic_id = env->cpu_index;
2138
2139     /* init various static tables used in TCG mode */
2140     if (tcg_enabled() && !inited) {
2141         inited = 1;
2142         optimize_flags_init();
2143 #ifndef CONFIG_USER_ONLY
2144         cpu_set_debug_excp_handler(breakpoint_handler);
2145 #endif
2146     }
2147 }
2148
2149 static void x86_cpu_common_class_init(ObjectClass *oc, void *data)
2150 {
2151     X86CPUClass *xcc = X86_CPU_CLASS(oc);
2152     CPUClass *cc = CPU_CLASS(oc);
2153
2154     xcc->parent_reset = cc->reset;
2155     cc->reset = x86_cpu_reset;
2156 }
2157
2158 static const TypeInfo x86_cpu_type_info = {
2159     .name = TYPE_X86_CPU,
2160     .parent = TYPE_CPU,
2161     .instance_size = sizeof(X86CPU),
2162     .instance_init = x86_cpu_initfn,
2163     .abstract = false,
2164     .class_size = sizeof(X86CPUClass),
2165     .class_init = x86_cpu_common_class_init,
2166 };
2167
2168 static void x86_cpu_register_types(void)
2169 {
2170     type_register_static(&x86_cpu_type_info);
2171 }
2172
2173 type_init(x86_cpu_register_types)