Merge pull request #315 from intel/cpuid-opt

cpuid: Optimize CPUID storage structure

Author: wcwang

core/cpuid.c

@@ -55,13 +55,32 @@ typedef union cpuid_feature_t {
  uint32_t value;
 } cpuid_feature_t;
 
+typedef void (*set_feature_t)(hax_cpuid_entry *, hax_cpuid *, uint32_t);
+
+typedef struct cpuid_set_t {
+ uint32_t function;
+ set_feature_t set_feature;
+} cpuid_set_t;
+
 static cpuid_cache_t cache = {0};
 
-static hax_cpuid_entry * find_cpuid_entry(hax_cpuid *cpuid_info,
- uint32_t function, uint32_t index);
-static void cpuid_set_0000_0001(hax_cpuid_t *cpuid, hax_cpuid *cpuid_info);
-static void cpuid_set_8000_0001(hax_cpuid_t *cpuid, hax_cpuid *cpuid_info);
-static void cpuid_set_fixed_features(hax_cpuid_t *cpuid);
+static hax_cpuid_entry * find_cpuid_entry(hax_cpuid_entry *features,
+ uint32_t size, uint32_t function,
+ uint32_t index);
+static void set_feature(hax_cpuid_entry *features, hax_cpuid *cpuid_info,
+ uint32_t function);
+static void set_feature_0000_0001(hax_cpuid_entry *features,
+ hax_cpuid *cpuid_info, uint32_t function);
+static void cpuid_set_fixed_features(hax_cpuid_entry *features,
+ uint32_t function);
+static void dump_features(hax_cpuid_entry *features, uint32_t size);
+static uint32_t get_feature_key_leaf(uint32_t function, uint32_t reg,
+ uint32_t bit);
+
+static const cpuid_set_t kCpuidSet[CPUID_FEATURE_SET_SIZE] = {
+ {0x00000001, set_feature_0000_0001},
+ {0x80000001, set_feature}
+};
 
 void cpuid_query_leaf(cpuid_args_t *args, uint32_t leaf)
 {
@@ -134,42 +153,41 @@ bool cpuid_host_has_feature_uncached(uint32_t feature_key)
 
 void cpuid_init_supported_features(void)
 {
- uint32_t bit, flag, function, x86_feature;
+ uint32_t i, bit, flag, function, x86_feature;
+ hax_cpuid_entry *host_supported, *hax_supported;
 
  // Initialize host supported features
- for (bit = 0; bit < sizeof(uint32_t) * 8; ++bit) {
- flag = 1 << bit;
-
- function = 0x01;
- x86_feature = FEATURE_KEY_LEAF(0, function, CPUID_REG_ECX, bit);
- if (cpuid_host_has_feature(x86_feature)) {
- cache.host_supported.feature_1_ecx |= flag;
- }
-
- x86_feature = FEATURE_KEY_LEAF(1, function, CPUID_REG_EDX, bit);
- if (cpuid_host_has_feature(x86_feature)) {
- cache.host_supported.feature_1_edx |= flag;
- }
-
- function = 0x80000001;
- x86_feature = FEATURE_KEY_LEAF(5, function, CPUID_REG_EDX, bit);
- if (cpuid_host_has_feature(x86_feature)) {
- cache.host_supported.feature_8000_0001_edx |= flag;
+ host_supported = cache.host_supported.features;
+
+ for (i = 0; i < CPUID_FEATURE_SET_SIZE; ++i) {
+ function = kCpuidSet[i].function;
+ host_supported[i].function = function;
+
+ for (bit = 0; bit < sizeof(uint32_t) * 8; ++bit) {
+ flag = 1 << bit;
+
+#define SET_FEATURE_FLAG(r, n) \
+ x86_feature = get_feature_key_leaf(function, (n), bit); \
+ if (cpuid_host_has_feature(x86_feature)) { \
+ host_supported[i].r |= flag; \
+ }
+
+ SET_FEATURE_FLAG(eax, CPUID_REG_EAX);
+ SET_FEATURE_FLAG(ebx, CPUID_REG_EBX);
+ SET_FEATURE_FLAG(ecx, CPUID_REG_ECX);
+ SET_FEATURE_FLAG(edx, CPUID_REG_EDX);
+#undef SET_FEATURE_FLAG
  }
  }
 
  hax_log(HAX_LOGI, "%s: host supported features:\n", __func__);
- hax_log(HAX_LOGI, "feature_1_ecx: %08lx, feature_1_edx: %08lx\n",
- cache.host_supported.feature_1_ecx,
- cache.host_supported.feature_1_edx);
- hax_log(HAX_LOGI, "feature_8000_0001_ecx: %08lx, "
- "feature_8000_0001_edx: %08lx\n",
- cache.host_supported.feature_8000_0001_ecx,
- cache.host_supported.feature_8000_0001_edx);
+ dump_features(host_supported, CPUID_FEATURE_SET_SIZE);
 
  // Initialize HAXM supported features
- cache.hax_supported = (hax_cpuid_t){
- .feature_1_ecx =
+ hax_supported = cache.hax_supported.features;
+ hax_supported[0] = (hax_cpuid_entry){
+ .function = 0x01,
+ .ecx =
  FEATURE(SSE3) |
  FEATURE(SSSE3) |
  FEATURE(SSE41) |
@@ -179,7 +197,7 @@ void cpuid_init_supported_features(void)
  FEATURE(AESNI) |
  FEATURE(PCLMULQDQ) |
  FEATURE(POPCNT),
- .feature_1_edx =
+ .edx =
  FEATURE(PAT) |
  FEATURE(FPU) |
  FEATURE(VME) |
@@ -202,23 +220,19 @@ void cpuid_init_supported_features(void)
  FEATURE(SSE2) |
  FEATURE(SS) |
  FEATURE(PSE) |
- FEATURE(HTT),
- .feature_8000_0001_ecx = 0,
- .feature_8000_0001_edx =
+ FEATURE(HTT)
+ };
+ hax_supported[1] = (hax_cpuid_entry){
+ .function = 0x80000001,
+ .edx =
  FEATURE(NX) |
  FEATURE(SYSCALL) |
  FEATURE(RDTSCP) |
  FEATURE(EM64T)
  };
 
  hax_log(HAX_LOGI, "%s: HAXM supported features:\n", __func__);
- hax_log(HAX_LOGI, "feature_1_ecx: %08lx, feature_1_edx: %08lx\n",
- cache.hax_supported.feature_1_ecx,
- cache.hax_supported.feature_1_edx);
- hax_log(HAX_LOGI, "feature_8000_0001_ecx: %08lx, "
- "feature_8000_0001_edx: %08lx\n",
- cache.hax_supported.feature_8000_0001_ecx,
- cache.hax_supported.feature_8000_0001_edx);
+ dump_features(hax_supported, CPUID_FEATURE_SET_SIZE);
 }
 
 void cpuid_guest_init(hax_cpuid_t *cpuid)
@@ -237,130 +251,170 @@ void cpuid_set_features_mask(hax_cpuid_t *cpuid, uint64_t features_mask)
  cpuid->features_mask = features_mask;
 }
 
-void cpuid_get_guest_features(hax_cpuid_t *cpuid,
- uint32_t *cpuid_1_features_ecx,
- uint32_t *cpuid_1_features_edx,
- uint32_t *cpuid_8000_0001_features_ecx,
- uint32_t *cpuid_8000_0001_features_edx)
+void cpuid_get_guest_features(hax_cpuid_t *cpuid, hax_cpuid_entry *features)
 {
- *cpuid_1_features_ecx = cpuid->feature_1_ecx;
- *cpuid_1_features_edx = cpuid->feature_1_edx;
- *cpuid_8000_0001_features_ecx = cpuid->feature_8000_0001_ecx;
- *cpuid_8000_0001_features_edx = cpuid->feature_8000_0001_edx;
+ hax_cpuid_entry *entry;
+
+ if (cpuid == NULL || features == NULL)
+ return;
+
+ entry = find_cpuid_entry(cpuid->features, CPUID_FEATURE_SET_SIZE,
+ features->function, 0);
+ if (entry == NULL)
+ return;
+
+ *features = *entry;
 }
 
 void cpuid_set_guest_features(hax_cpuid_t *cpuid, hax_cpuid *cpuid_info)
 {
- static void (*cpuid_set_guest_feature[])(hax_cpuid_t *, hax_cpuid *) = {
- cpuid_set_0000_0001,
- cpuid_set_8000_0001
- };
- static size_t count = sizeof(cpuid_set_guest_feature) /
- sizeof(cpuid_set_guest_feature[0]);
  int i;
+ const cpuid_set_t *kItem;
+
+ if (cpuid == NULL || cpuid_info == NULL)
+ return;
+
+ hax_log(HAX_LOGI, "%s: user setting:\n", __func__);
+ dump_features(cpuid_info->entries, cpuid_info->total);
 
  hax_log(HAX_LOGI, "%s: before:\n", __func__);
- hax_log(HAX_LOGI, "feature_1_ecx: %08lx, feature_1_edx: %08lx\n",
- cpuid->feature_1_ecx, cpuid->feature_1_edx);
- hax_log(HAX_LOGI, "feature_8000_0001_ecx: %08lx, feature_8000_0001_edx: %08lx"
- "\n", cpuid->feature_8000_0001_ecx, cpuid->feature_8000_0001_edx);
+ dump_features(cpuid->features, CPUID_FEATURE_SET_SIZE);
 
- for (i = 0; i < count; ++i) {
- cpuid_set_guest_feature[i](cpuid, cpuid_info);
+ for (i = 0; i < CPUID_FEATURE_SET_SIZE; ++i) {
+ kItem = &kCpuidSet[i];
+ kItem->set_feature(cpuid->features, cpuid_info, kItem->function);
  }
 
  hax_log(HAX_LOGI, "%s: after:\n", __func__);
- hax_log(HAX_LOGI, "feature_1_ecx: %08lx, feature_1_edx: %08lx\n",
- cpuid->feature_1_ecx, cpuid->feature_1_edx);
- hax_log(HAX_LOGI, "feature_8000_0001_ecx: %08lx, feature_8000_0001_edx: %08lx"
- "\n", cpuid->feature_8000_0001_ecx, cpuid->feature_8000_0001_edx);
+ dump_features(cpuid->features, CPUID_FEATURE_SET_SIZE);
 }
 
-static hax_cpuid_entry * find_cpuid_entry(hax_cpuid *cpuid_info,
- uint32_t function, uint32_t index)
+static hax_cpuid_entry * find_cpuid_entry(hax_cpuid_entry *features,
+ uint32_t size, uint32_t function,
+ uint32_t index)
 {
  int i;
- hax_cpuid_entry *entry, *found = NULL;
+ hax_cpuid_entry *entry;
 
- for (i = 0; i < cpuid_info->total; ++i) {
- entry = &cpuid_info->entries[i];
- if (entry->function == function && entry->index == index) {
- found = entry;
- break;
- }
+ if (features == NULL)
+ return NULL;
+
+ for (i = 0; i < size; ++i) {
+ entry = &features[i];
+ if (entry->function == function && entry->index == index)
+ return entry;
  }
 
- return found;
+ return NULL;
 }
 
-static void cpuid_set_0000_0001(hax_cpuid_t *cpuid, hax_cpuid *cpuid_info)
+static void set_feature(hax_cpuid_entry *features, hax_cpuid *cpuid_info,
+ uint32_t function)
 {
- const uint32_t kFunction = 0x01;
- hax_cpuid_entry *entry;
+ hax_cpuid_entry *dest, *src, *host_supported, *hax_supported;
 
- entry = find_cpuid_entry(cpuid_info, kFunction, 0);
- if (entry == NULL)
+ if (features == NULL || cpuid_info == NULL)
  return;
 
- hax_log(HAX_LOGI, "%s: function: %08lx, index: %lu, flags: %08lx\n",
- __func__, entry->function, entry->index, entry->flags);
- hax_log(HAX_LOGI, "%s: eax: %08lx, ebx: %08lx, ecx: %08lx, edx: %08lx\n",
- __func__, entry->eax, entry->ebx, entry->ecx, entry->edx);
+ dest = find_cpuid_entry(features, CPUID_FEATURE_SET_SIZE, function, 0);
+ if (dest == NULL)
+ return;
 
- cpuid->feature_1_ecx = entry->ecx;
- cpuid->feature_1_edx = entry->edx;
+ src = find_cpuid_entry(cpuid_info->entries, cpuid_info->total, function, 0);
+ if (src == NULL)
+ return;
 
- // Filter the unsupported features
- cpuid->feature_1_ecx &= cache.host_supported.feature_1_ecx &
- cache.hax_supported.feature_1_ecx;
- cpuid->feature_1_edx &= cache.host_supported.feature_1_edx &
- cache.hax_supported.feature_1_edx;
+ host_supported = find_cpuid_entry(cache.host_supported.features,
+ CPUID_FEATURE_SET_SIZE, function, 0);
+ hax_supported = find_cpuid_entry(cache.hax_supported.features,
+ CPUID_FEATURE_SET_SIZE, function, 0);
 
- // Set fixed supported features
- cpuid_set_fixed_features(cpuid);
+ if (host_supported == NULL || hax_supported == NULL)
+  return;
 
- if (entry->ecx != cpuid->feature_1_ecx ||
- entry->edx != cpuid->feature_1_edx) {
- hax_log(HAX_LOGW, "%s: filtered or unchanged flags: ecx: %08lx, "
- "edx: %08lx\n", __func__, entry->ecx ^ cpuid->feature_1_ecx,
- entry->edx ^ cpuid->feature_1_edx);
- }
+ *dest = *src;
+ dest->eax &= host_supported->eax & hax_supported->eax;
+ dest->ebx &= host_supported->ebx & hax_supported->ebx;
+ dest->ecx &= host_supported->ecx & hax_supported->ecx;
+ dest->edx &= host_supported->edx & hax_supported->edx;
+
+ if (src->eax == dest->eax && src->ebx == dest->ebx &&
+ src->ecx == dest->ecx && src->edx == dest->edx)
+ return;
+
+ hax_log(HAX_LOGW, "%s: filtered or unchanged flags:\n", __func__);
+ hax_log(HAX_LOGW, "function: %08lx, eax: %08lx, ebx: %08lx, ecx: %08lx, "
+ "edx: %08lx\n", function, src->eax ^ dest->eax,
+ src->ebx ^ dest->ebx, src->ecx ^ dest->ecx, src->edx ^ dest->edx);
+}
+
+static void set_feature_0000_0001(hax_cpuid_entry *features,
+ hax_cpuid *cpuid_info, uint32_t function)
+{
+ if (features == NULL || cpuid_info == NULL)
+ return;
+
+ set_feature(features, cpuid_info, function);
+ // Set fixed supported features
+ cpuid_set_fixed_features(features, function);
 }
 
-static void cpuid_set_8000_0001(hax_cpuid_t *cpuid, hax_cpuid *cpuid_info)
+static void cpuid_set_fixed_features(hax_cpuid_entry *features,
+ uint32_t function)
 {
- const uint32_t kFunction = 0x80000001;
+ const uint32_t kFixedFeatures =
+ FEATURE(MCE) |
+ FEATURE(APIC) |
+ FEATURE(MTRR) |
+ FEATURE(PAT);
  hax_cpuid_entry *entry;
 
- entry = find_cpuid_entry(cpuid_info, kFunction, 0);
+ if (features == NULL)
+ return;
+
+ entry = find_cpuid_entry(features, CPUID_FEATURE_SET_SIZE, function, 0);
  if (entry == NULL)
  return;
 
- hax_log(HAX_LOGI, "%s: function: %08lx, index: %lu, flags: %08lx\n",
- __func__, entry->function, entry->index, entry->flags);
- hax_log(HAX_LOGI, "%s: eax: %08lx, ebx: %08lx, ecx: %08lx, edx: %08lx\n",
- __func__, entry->eax, entry->ebx, entry->ecx, entry->edx);
+ entry->edx |= kFixedFeatures;
+}
 
- cpuid->feature_8000_0001_edx = entry->edx;
+static void dump_features(hax_cpuid_entry *features, uint32_t size)
+{
+ int i;
+ hax_cpuid_entry *entry;
 
- // Filter the unsupported features
- cpuid->feature_8000_0001_edx &=
- cache.host_supported.feature_8000_0001_edx &
- cache.hax_supported.feature_8000_0001_edx;
+ if (features == NULL)
+ return;
 
- if (entry->edx != cpuid->feature_8000_0001_edx) {
- hax_log(HAX_LOGW, "%s: filtered or unchanged flags: edx: %08lx\n",
- __func__, entry->edx ^ cpuid->feature_8000_0001_edx);
+ for (i = 0; i < size; ++i) {
+ entry = &features[i];
+ hax_log(HAX_LOGI, "function: %08lx, index: %lu, flags: %08lx\n",
+ entry->function, entry->index, entry->flags);
+ hax_log(HAX_LOGI, "eax: %08lx, ebx: %08lx, ecx: %08lx, edx: %08lx\n",
+ entry->eax, entry->ebx, entry->ecx, entry->edx);
  }
 }
 
-static void cpuid_set_fixed_features(hax_cpuid_t *cpuid)
+static uint32_t get_feature_key_leaf(uint32_t function, uint32_t reg,
+ uint32_t bit)
 {
- const uint32_t kFixedFeatures =
- FEATURE(MCE) |
- FEATURE(APIC) |
- FEATURE(MTRR) |
- FEATURE(PAT);
+ if (function == 0x01) {
+ if (reg == CPUID_REG_ECX)
+ return FEATURE_KEY_LEAF(0, function, reg, bit);
+
+ if (reg == CPUID_REG_EDX)
+ return FEATURE_KEY_LEAF(1, function, reg, bit);
+
+ return -1;
+ }
+
+ if (function == 0x80000001) {
+ if (reg == CPUID_REG_EDX)
+ return FEATURE_KEY_LEAF(5, function, reg, bit);
+
+ return -1;
+ }
 
- cpuid->feature_1_edx |= kFixedFeatures;
+ return -1;
 }