NuKVM/libvirt
3
0
Fork 0
mirror of https://github.com/libvirt/libvirt.git synced 2025-02-25 18:55:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

cpu_x86: Avoid unnecessary pointers to virCPUx86Data

Browse Source 
virCPUData, virCPUx86Feature, and virCPUx86Model all contained a pointer
to virCPUx86Data, which was not very nice since the real CPUID data were
accessible by yet another pointer from virCPUx86Data. Moreover, using
virCPUx86Data directly will make static definitions of internal CPU
features a bit easier.

Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
This commit is contained in:
Jiri Denemark 2016-06-07 09:38:53 +02:00
parent 474e627892
commit 9ea32aecb4
6 changed files with 142 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cpu/cpu.h
View File

@ -37,7 +37,7 @@ typedef virCPUData *virCPUDataPtr;
struct _virCPUData { struct _virCPUData {
virArch arch; virArch arch;
union { union {
virCPUx86Data *x86; virCPUx86Data x86;
virCPUppc64Data *ppc64; virCPUppc64Data *ppc64;
/* generic driver needs no data */ /* generic driver needs no data */
} data; } data;

308
src/cpu/cpu_x86.c
View File

@ -55,7 +55,7 @@ typedef struct _virCPUx86Feature virCPUx86Feature;
typedef virCPUx86Feature *virCPUx86FeaturePtr; typedef virCPUx86Feature *virCPUx86FeaturePtr;
struct _virCPUx86Feature { struct _virCPUx86Feature {
char *name; char *name;
virCPUx86Data *data; virCPUx86Data data;
bool migratable; bool migratable;
}; };
@ -93,7 +93,7 @@ typedef virCPUx86Model *virCPUx86ModelPtr;
struct _virCPUx86Model { struct _virCPUx86Model {
char *name; char *name;
virCPUx86VendorPtr vendor; virCPUx86VendorPtr vendor;
virCPUx86Data *data; virCPUx86Data data;
}; };
typedef struct _virCPUx86Map virCPUx86Map; typedef struct _virCPUx86Map virCPUx86Map;
@ -245,18 +245,17 @@ x86DataCpuid(const virCPUx86Data *data,
} }
void void
virCPUx86DataFree(virCPUx86Data *data) virCPUx86DataClear(virCPUx86Data *data)
{ {
if (!data) if (!data)
return; return;
VIR_FREE(data->data); VIR_FREE(data->data);
VIR_FREE(data);
} }
virCPUDataPtr virCPUDataPtr
virCPUx86MakeData(virArch arch, virCPUx86Data **data) virCPUx86MakeData(virArch arch, virCPUx86Data *data)
{ {
virCPUDataPtr cpuData; virCPUDataPtr cpuData;
@ -265,7 +264,8 @@ virCPUx86MakeData(virArch arch, virCPUx86Data **data)
cpuData->arch = arch; cpuData->arch = arch;
cpuData->data.x86 = *data; cpuData->data.x86 = *data;
*data = NULL; data->len = 0;
data->data = NULL;
return cpuData; return cpuData;
} }
@ -276,28 +276,24 @@ x86FreeCPUData(virCPUDataPtr data)
if (!data) if (!data)
return; return;
virCPUx86DataFree(data->data.x86); virCPUx86DataClear(&data->data.x86);
VIR_FREE(data); VIR_FREE(data);
} }
static virCPUx86Data * static int
x86DataCopy(const virCPUx86Data *data) x86DataCopy(virCPUx86Data *dst, const virCPUx86Data *src)
{ {
virCPUx86Data *copy = NULL;
size_t i; size_t i;
if (VIR_ALLOC(copy) < 0 || if (VIR_ALLOC_N(dst->data, src->len) < 0)
VIR_ALLOC_N(copy->data, data->len) < 0) { return -1;
virCPUx86DataFree(copy);
return NULL;
}
copy->len = data->len; dst->len = src->len;
for (i = 0; i < data->len; i++) for (i = 0; i < src->len; i++)
copy->data[i] = data->data[i]; dst->data[i] = src->data[i];
return copy; return 0;
} }
@ -417,8 +413,8 @@ x86DataToCPUFeatures(virCPUDefPtr cpu,
for (i = 0; i < map->nfeatures; i++) { for (i = 0; i < map->nfeatures; i++) {
virCPUx86FeaturePtr feature = map->features[i]; virCPUx86FeaturePtr feature = map->features[i];
if (x86DataIsSubset(data, feature->data)) { if (x86DataIsSubset(data, &feature->data)) {
x86DataSubtract(data, feature->data); x86DataSubtract(data, &feature->data);
if (virCPUDefAddFeature(cpu, feature->name, policy) < 0) if (virCPUDefAddFeature(cpu, feature->name, policy) < 0)
return -1; return -1;
} }
@ -455,33 +451,33 @@ x86DataToCPU(const virCPUx86Data *data,
virCPUx86MapPtr map) virCPUx86MapPtr map)
{ {
virCPUDefPtr cpu; virCPUDefPtr cpu;
virCPUx86Data *copy = NULL; virCPUx86Data copy = VIR_CPU_X86_DATA_INIT;
virCPUx86Data *modelData = NULL; virCPUx86Data modelData = VIR_CPU_X86_DATA_INIT;
virCPUx86VendorPtr vendor; virCPUx86VendorPtr vendor;
if (VIR_ALLOC(cpu) < 0 || if (VIR_ALLOC(cpu) < 0 ||
VIR_STRDUP(cpu->model, model->name) < 0 || VIR_STRDUP(cpu->model, model->name) < 0 ||
!(copy = x86DataCopy(data)) || x86DataCopy(&copy, data) < 0 ||
!(modelData = x86DataCopy(model->data))) x86DataCopy(&modelData, &model->data) < 0)
goto error; goto error;
if ((vendor = x86DataToVendor(copy, map)) && if ((vendor = x86DataToVendor(&copy, map)) &&
VIR_STRDUP(cpu->vendor, vendor->name) < 0) VIR_STRDUP(cpu->vendor, vendor->name) < 0)
goto error; goto error;
x86DataSubtract(copy, modelData); x86DataSubtract(&copy, &modelData);
x86DataSubtract(modelData, data); x86DataSubtract(&modelData, data);
/* because feature policy is ignored for host CPU */ /* because feature policy is ignored for host CPU */
cpu->type = VIR_CPU_TYPE_GUEST; cpu->type = VIR_CPU_TYPE_GUEST;
if (x86DataToCPUFeatures(cpu, VIR_CPU_FEATURE_REQUIRE, copy, map) || if (x86DataToCPUFeatures(cpu, VIR_CPU_FEATURE_REQUIRE, &copy, map) ||
x86DataToCPUFeatures(cpu, VIR_CPU_FEATURE_DISABLE, modelData, map)) x86DataToCPUFeatures(cpu, VIR_CPU_FEATURE_DISABLE, &modelData, map))
goto error; goto error;
cleanup: cleanup:
virCPUx86DataFree(modelData); virCPUx86DataClear(&modelData);
virCPUx86DataFree(copy); virCPUx86DataClear(&copy);
return cpu; return cpu;
error: error:
@ -600,11 +596,6 @@ x86FeatureNew(void)
if (VIR_ALLOC(feature) < 0) if (VIR_ALLOC(feature) < 0)
return NULL; return NULL;
if (VIR_ALLOC(feature->data) < 0) {
VIR_FREE(feature);
return NULL;
}
return feature; return feature;
} }
@ -616,7 +607,7 @@ x86FeatureFree(virCPUx86FeaturePtr feature)
return; return;
VIR_FREE(feature->name); VIR_FREE(feature->name);
virCPUx86DataFree(feature->data); virCPUx86DataClear(&feature->data);
VIR_FREE(feature); VIR_FREE(feature);
} }
@ -649,7 +640,7 @@ x86FeatureNames(virCPUx86MapPtr map,
for (i = 0; i < map->nfeatures; i++) { for (i = 0; i < map->nfeatures; i++) {
virCPUx86FeaturePtr feature = map->features[i]; virCPUx86FeaturePtr feature = map->features[i];
if (x86DataIsSubset(data, feature->data)) { if (x86DataIsSubset(data, &feature->data)) {
if (!first) if (!first)
virBufferAdd(&ret, separator, -1); virBufferAdd(&ret, separator, -1);
else else
@ -738,7 +729,7 @@ x86FeatureParse(xmlXPathContextPtr ctxt,
i, feature->name); i, feature->name);
goto error; goto error;
} }
if (virCPUx86DataAddCPUID(feature->data, &cpuid)) if (virCPUx86DataAddCPUID(&feature->data, &cpuid))
goto error; goto error;
} }
@ -781,33 +772,26 @@ x86FeaturesLoad(virCPUx86MapPtr map,
return 0; return 0;
} }
static virCPUx86Data * static int
x86DataFromCPUFeatures(virCPUDefPtr cpu, x86DataFromCPUFeatures(virCPUx86Data *data,
virCPUDefPtr cpu,
virCPUx86MapPtr map) virCPUx86MapPtr map)
{ {
virCPUx86Data *data;
size_t i; size_t i;
if (VIR_ALLOC(data) < 0)
return NULL;
for (i = 0; i < cpu->nfeatures; i++) { for (i = 0; i < cpu->nfeatures; i++) {
virCPUx86FeaturePtr feature; virCPUx86FeaturePtr feature;
if (!(feature = x86FeatureFind(map, cpu->features[i].name))) { if (!(feature = x86FeatureFind(map, cpu->features[i].name))) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unknown CPU feature %s"), cpu->features[i].name); _("Unknown CPU feature %s"), cpu->features[i].name);
goto error; return -1;
} }
if (x86DataAdd(data, feature->data) < 0) if (x86DataAdd(data, &feature->data) < 0)
goto error; return -1;
} }
return data; return 0;
error:
virCPUx86DataFree(data);
return NULL;
} }
@ -819,11 +803,6 @@ x86ModelNew(void)
if (VIR_ALLOC(model) < 0) if (VIR_ALLOC(model) < 0)
return NULL; return NULL;
if (VIR_ALLOC(model->data) < 0) {
VIR_FREE(model);
return NULL;
}
return model; return model;
} }
@ -835,7 +814,7 @@ x86ModelFree(virCPUx86ModelPtr model)
return; return;
VIR_FREE(model->name); VIR_FREE(model->name);
virCPUx86DataFree(model->data); virCPUx86DataClear(&model->data);
VIR_FREE(model); VIR_FREE(model);
} }
@ -847,7 +826,7 @@ x86ModelCopy(virCPUx86ModelPtr model)
if (VIR_ALLOC(copy) < 0 || if (VIR_ALLOC(copy) < 0 ||
VIR_STRDUP(copy->name, model->name) < 0 || VIR_STRDUP(copy->name, model->name) < 0 ||
!(copy->data = x86DataCopy(model->data))) { x86DataCopy(&copy->data, &model->data) < 0) {
x86ModelFree(copy); x86ModelFree(copy);
return NULL; return NULL;
} }
@ -909,7 +888,7 @@ x86ModelFromCPU(const virCPUDef *cpu,
goto error; goto error;
} }
if (x86DataAdd(model->data, feature->data)) if (x86DataAdd(&model->data, &feature->data))
goto error; goto error;
} }
@ -936,7 +915,7 @@ x86ModelSubtractCPU(virCPUx86ModelPtr model,
return -1; return -1;
} }
x86DataSubtract(model->data, cpu_model->data); x86DataSubtract(&model->data, &cpu_model->data);
for (i = 0; i < cpu->nfeatures; i++) { for (i = 0; i < cpu->nfeatures; i++) {
virCPUx86FeaturePtr feature; virCPUx86FeaturePtr feature;
@ -948,7 +927,7 @@ x86ModelSubtractCPU(virCPUx86ModelPtr model,
return -1; return -1;
} }
x86DataSubtract(model->data, feature->data); x86DataSubtract(&model->data, &feature->data);
} }
return 0; return 0;
@ -960,15 +939,15 @@ x86ModelCompare(virCPUx86ModelPtr model1,
virCPUx86ModelPtr model2) virCPUx86ModelPtr model2)
{ {
virCPUx86CompareResult result = EQUAL; virCPUx86CompareResult result = EQUAL;
virCPUx86DataIterator iter1 = virCPUx86DataIteratorInit(model1->data); virCPUx86DataIterator iter1 = virCPUx86DataIteratorInit(&model1->data);
virCPUx86DataIterator iter2 = virCPUx86DataIteratorInit(model2->data); virCPUx86DataIterator iter2 = virCPUx86DataIteratorInit(&model2->data);
virCPUx86CPUID *cpuid1; virCPUx86CPUID *cpuid1;
virCPUx86CPUID *cpuid2; virCPUx86CPUID *cpuid2;
while ((cpuid1 = x86DataCpuidNext(&iter1))) { while ((cpuid1 = x86DataCpuidNext(&iter1))) {
virCPUx86CompareResult match = SUPERSET; virCPUx86CompareResult match = SUPERSET;
if ((cpuid2 = x86DataCpuid(model2->data, cpuid1->eax_in))) { if ((cpuid2 = x86DataCpuid(&model2->data, cpuid1->eax_in))) {
if (x86cpuidMatch(cpuid1, cpuid2)) if (x86cpuidMatch(cpuid1, cpuid2))
continue; continue;
else if (!x86cpuidMatchMasked(cpuid1, cpuid2)) else if (!x86cpuidMatchMasked(cpuid1, cpuid2))
@ -984,7 +963,7 @@ x86ModelCompare(virCPUx86ModelPtr model1,
while ((cpuid2 = x86DataCpuidNext(&iter2))) { while ((cpuid2 = x86DataCpuidNext(&iter2))) {
virCPUx86CompareResult match = SUBSET; virCPUx86CompareResult match = SUBSET;
if ((cpuid1 = x86DataCpuid(model1->data, cpuid2->eax_in))) { if ((cpuid1 = x86DataCpuid(&model1->data, cpuid2->eax_in))) {
if (x86cpuidMatch(cpuid2, cpuid1)) if (x86cpuidMatch(cpuid2, cpuid1))
continue; continue;
else if (!x86cpuidMatchMasked(cpuid2, cpuid1)) else if (!x86cpuidMatchMasked(cpuid2, cpuid1))
@ -1044,8 +1023,7 @@ x86ModelParse(xmlXPathContextPtr ctxt,
VIR_FREE(name); VIR_FREE(name);
model->vendor = ancestor->vendor; model->vendor = ancestor->vendor;
virCPUx86DataFree(model->data); if (x86DataCopy(&model->data, &ancestor->data) < 0)
if (!(model->data = x86DataCopy(ancestor->data)))
goto error; goto error;
} }
@ -1089,7 +1067,7 @@ x86ModelParse(xmlXPathContextPtr ctxt,
} }
VIR_FREE(name); VIR_FREE(name);
if (x86DataAdd(model->data, feature->data)) if (x86DataAdd(&model->data, &feature->data))
goto error; goto error;
} }
@ -1207,7 +1185,7 @@ x86MapLoadInternalFeatures(virCPUx86MapPtr map)
if (VIR_STRDUP(feature->name, name) < 0) if (VIR_STRDUP(feature->name, name) < 0)
goto error; goto error;
if (virCPUx86DataAddCPUID(feature->data, &x86_kvm_features[i].cpuid)) if (virCPUx86DataAddCPUID(&feature->data, &x86_kvm_features[i].cpuid))
goto error; goto error;
map->features[map->nfeatures++] = feature; map->features[map->nfeatures++] = feature;
@ -1267,7 +1245,7 @@ virCPUx86GetMap(void)
static char * static char *
x86CPUDataFormat(const virCPUData *data) x86CPUDataFormat(const virCPUData *data)
{ {
virCPUx86DataIterator iter = virCPUx86DataIteratorInit(data->data.x86); virCPUx86DataIterator iter = virCPUx86DataIteratorInit(&data->data.x86);
virCPUx86CPUID *cpuid; virCPUx86CPUID *cpuid;
virBuffer buf = VIR_BUFFER_INITIALIZER; virBuffer buf = VIR_BUFFER_INITIALIZER;
@ -1294,14 +1272,11 @@ x86CPUDataParse(xmlXPathContextPtr ctxt)
{ {
xmlNodePtr *nodes = NULL; xmlNodePtr *nodes = NULL;
virCPUDataPtr cpuData = NULL; virCPUDataPtr cpuData = NULL;
virCPUx86Data *data = NULL; virCPUx86Data data = VIR_CPU_X86_DATA_INIT;
virCPUx86CPUID cpuid; virCPUx86CPUID cpuid;
size_t i; size_t i;
int n; int n;
if (VIR_ALLOC(data) < 0)
goto cleanup;
n = virXPathNodeSet("/cpudata/cpuid", ctxt, &nodes); n = virXPathNodeSet("/cpudata/cpuid", ctxt, &nodes);
if (n <= 0) { if (n <= 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@ -1316,7 +1291,7 @@ x86CPUDataParse(xmlXPathContextPtr ctxt)
_("failed to parse cpuid[%zu]"), i); _("failed to parse cpuid[%zu]"), i);
goto cleanup; goto cleanup;
} }
if (virCPUx86DataAddCPUID(data, &cpuid) < 0) if (virCPUx86DataAddCPUID(&data, &cpuid) < 0)
goto cleanup; goto cleanup;
} }
@ -1324,7 +1299,7 @@ x86CPUDataParse(xmlXPathContextPtr ctxt)
cleanup: cleanup:
VIR_FREE(nodes); VIR_FREE(nodes);
virCPUx86DataFree(data); virCPUx86DataClear(&data);
return cpuData; return cpuData;
} }
@ -1370,6 +1345,7 @@ x86Compute(virCPUDefPtr host,
virCPUx86ModelPtr cpu_forbid = NULL; virCPUx86ModelPtr cpu_forbid = NULL;
virCPUx86ModelPtr diff = NULL; virCPUx86ModelPtr diff = NULL;
virCPUx86ModelPtr guest_model = NULL; virCPUx86ModelPtr guest_model = NULL;
virCPUx86Data guestData = VIR_CPU_X86_DATA_INIT;
virCPUCompareResult ret; virCPUCompareResult ret;
virCPUx86CompareResult result; virCPUx86CompareResult result;
virArch arch; virArch arch;
@ -1429,25 +1405,25 @@ x86Compute(virCPUDefPtr host,
!(cpu_forbid = x86ModelFromCPU(cpu, map, VIR_CPU_FEATURE_FORBID))) !(cpu_forbid = x86ModelFromCPU(cpu, map, VIR_CPU_FEATURE_FORBID)))
goto error; goto error;
x86DataIntersect(cpu_forbid->data, host_model->data); x86DataIntersect(&cpu_forbid->data, &host_model->data);
if (!x86DataIsEmpty(cpu_forbid->data)) { if (!x86DataIsEmpty(&cpu_forbid->data)) {
virX86CpuIncompatible(N_("Host CPU provides forbidden features"), virX86CpuIncompatible(N_("Host CPU provides forbidden features"),
cpu_forbid->data); &cpu_forbid->data);
goto cleanup; goto cleanup;
} }
/* first remove features that were inherited from the CPU model and were /* first remove features that were inherited from the CPU model and were
* explicitly forced, disabled, or made optional * explicitly forced, disabled, or made optional
*/ */
x86DataSubtract(cpu_require->data, cpu_force->data); x86DataSubtract(&cpu_require->data, &cpu_force->data);
x86DataSubtract(cpu_require->data, cpu_optional->data); x86DataSubtract(&cpu_require->data, &cpu_optional->data);
x86DataSubtract(cpu_require->data, cpu_disable->data); x86DataSubtract(&cpu_require->data, &cpu_disable->data);
result = x86ModelCompare(host_model, cpu_require); result = x86ModelCompare(host_model, cpu_require);
if (result == SUBSET || result == UNRELATED) { if (result == SUBSET || result == UNRELATED) {
x86DataSubtract(cpu_require->data, host_model->data); x86DataSubtract(&cpu_require->data, &host_model->data);
virX86CpuIncompatible(N_("Host CPU does not provide required " virX86CpuIncompatible(N_("Host CPU does not provide required "
"features"), "features"),
cpu_require->data); &cpu_require->data);
goto cleanup; goto cleanup;
} }
@ -1456,12 +1432,12 @@ x86Compute(virCPUDefPtr host,
if (!(diff = x86ModelCopy(host_model))) if (!(diff = x86ModelCopy(host_model)))
goto error; goto error;
x86DataSubtract(diff->data, cpu_optional->data); x86DataSubtract(&diff->data, &cpu_optional->data);
x86DataSubtract(diff->data, cpu_require->data); x86DataSubtract(&diff->data, &cpu_require->data);
x86DataSubtract(diff->data, cpu_disable->data); x86DataSubtract(&diff->data, &cpu_disable->data);
x86DataSubtract(diff->data, cpu_force->data); x86DataSubtract(&diff->data, &cpu_force->data);
if (!x86DataIsEmpty(diff->data)) if (!x86DataIsEmpty(&diff->data))
ret = VIR_CPU_COMPARE_SUPERSET; ret = VIR_CPU_COMPARE_SUPERSET;
if (ret == VIR_CPU_COMPARE_SUPERSET if (ret == VIR_CPU_COMPARE_SUPERSET
@ -1469,35 +1445,31 @@ x86Compute(virCPUDefPtr host,
&& cpu->match == VIR_CPU_MATCH_STRICT) { && cpu->match == VIR_CPU_MATCH_STRICT) {
virX86CpuIncompatible(N_("Host CPU does not strictly match guest CPU: " virX86CpuIncompatible(N_("Host CPU does not strictly match guest CPU: "
"Extra features"), "Extra features"),
diff->data); &diff->data);
goto cleanup; goto cleanup;
} }
if (guest) { if (guest) {
virCPUx86Data *guestData;
if (!(guest_model = x86ModelCopy(host_model))) if (!(guest_model = x86ModelCopy(host_model)))
goto error; goto error;
if (cpu->vendor && if (cpu->vendor &&
virCPUx86DataAddCPUID(guest_model->data, virCPUx86DataAddCPUID(&guest_model->data,
&host_model->vendor->cpuid) < 0) &host_model->vendor->cpuid) < 0)
goto error; goto error;
if (cpu->type == VIR_CPU_TYPE_GUEST if (cpu->type == VIR_CPU_TYPE_GUEST
&& cpu->match == VIR_CPU_MATCH_EXACT) && cpu->match == VIR_CPU_MATCH_EXACT)
x86DataSubtract(guest_model->data, diff->data); x86DataSubtract(&guest_model->data, &diff->data);
if (x86DataAdd(guest_model->data, cpu_force->data)) if (x86DataAdd(&guest_model->data, &cpu_force->data))
goto error; goto error;
x86DataSubtract(guest_model->data, cpu_disable->data); x86DataSubtract(&guest_model->data, &cpu_disable->data);
if (!(guestData = x86DataCopy(guest_model->data)) || if (x86DataCopy(&guestData, &guest_model->data) < 0 ||
!(*guest = virCPUx86MakeData(arch, &guestData))) { !(*guest = virCPUx86MakeData(arch, &guestData)))
virCPUx86DataFree(guestData);
goto error; goto error;
}
} }
cleanup: cleanup:
@ -1509,6 +1481,7 @@ x86Compute(virCPUDefPtr host,
x86ModelFree(cpu_disable); x86ModelFree(cpu_disable);
x86ModelFree(cpu_forbid); x86ModelFree(cpu_forbid);
x86ModelFree(guest_model); x86ModelFree(guest_model);
virCPUx86DataClear(&guestData);
return ret; return ret;
@ -1603,8 +1576,8 @@ x86Decode(virCPUDefPtr cpu,
virCPUx86ModelPtr candidate; virCPUx86ModelPtr candidate;
virCPUDefPtr cpuCandidate; virCPUDefPtr cpuCandidate;
virCPUDefPtr cpuModel = NULL; virCPUDefPtr cpuModel = NULL;
virCPUx86Data *copy = NULL; virCPUx86Data copy = VIR_CPU_X86_DATA_INIT;
virCPUx86Data *features = NULL; virCPUx86Data features = VIR_CPU_X86_DATA_INIT;
const virCPUx86Data *cpuData = NULL; const virCPUx86Data *cpuData = NULL;
virCPUx86VendorPtr vendor; virCPUx86VendorPtr vendor;
ssize_t i; ssize_t i;
@ -1659,7 +1632,7 @@ x86Decode(virCPUDefPtr cpu,
cpu->type == VIR_CPU_TYPE_HOST))) { cpu->type == VIR_CPU_TYPE_HOST))) {
virCPUDefFree(cpuModel); virCPUDefFree(cpuModel);
cpuModel = cpuCandidate; cpuModel = cpuCandidate;
cpuData = candidate->data; cpuData = &candidate->data;
if (rc == 2) if (rc == 2)
break; break;
} else { } else {
@ -1691,13 +1664,13 @@ x86Decode(virCPUDefPtr cpu,
} }
if (flags & VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES) { if (flags & VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES) {
if (!(copy = x86DataCopy(cpuData)) || if (x86DataCopy(&copy, cpuData) < 0 ||
!(features = x86DataFromCPUFeatures(cpuModel, map))) x86DataFromCPUFeatures(&features, cpuModel, map) < 0)
goto cleanup; goto cleanup;
x86DataSubtract(copy, features); x86DataSubtract(&copy, &features);
if (x86DataToCPUFeatures(cpuModel, VIR_CPU_FEATURE_REQUIRE, if (x86DataToCPUFeatures(cpuModel, VIR_CPU_FEATURE_REQUIRE,
copy, map) < 0) &copy, map) < 0)
goto cleanup; goto cleanup;
} }
@ -1713,8 +1686,8 @@ x86Decode(virCPUDefPtr cpu,
cleanup: cleanup:
virCPUDefFree(cpuModel); virCPUDefFree(cpuModel);
virCPUx86DataFree(copy); virCPUx86DataClear(&copy);
virCPUx86DataFree(features); virCPUx86DataClear(&features);
return ret; return ret;
} }
@ -1726,26 +1699,27 @@ x86DecodeCPUData(virCPUDefPtr cpu,
const char *preferred, const char *preferred,
unsigned int flags) unsigned int flags)
{ {
return x86Decode(cpu, data->data.x86, models, nmodels, preferred, flags); return x86Decode(cpu, &data->data.x86, models, nmodels, preferred, flags);
} }
static virCPUx86Data * static int
x86EncodePolicy(const virCPUDef *cpu, x86EncodePolicy(virCPUx86Data *data,
const virCPUDef *cpu,
virCPUx86MapPtr map, virCPUx86MapPtr map,
virCPUFeaturePolicy policy) virCPUFeaturePolicy policy)
{ {
virCPUx86ModelPtr model; virCPUx86ModelPtr model;
virCPUx86Data *data = NULL;
if (!(model = x86ModelFromCPU(cpu, map, policy))) if (!(model = x86ModelFromCPU(cpu, map, policy)))
return NULL; return -1;
data = model->data; *data = model->data;
model->data = NULL; model->data.len = 0;
model->data.data = NULL;
x86ModelFree(model); x86ModelFree(model);
return data; return 0;
} }
@ -1760,12 +1734,12 @@ x86Encode(virArch arch,
virCPUDataPtr *vendor) virCPUDataPtr *vendor)
{ {
virCPUx86MapPtr map = NULL; virCPUx86MapPtr map = NULL;
virCPUx86Data *data_forced = NULL; virCPUx86Data data_forced = VIR_CPU_X86_DATA_INIT;
virCPUx86Data *data_required = NULL; virCPUx86Data data_required = VIR_CPU_X86_DATA_INIT;
virCPUx86Data *data_optional = NULL; virCPUx86Data data_optional = VIR_CPU_X86_DATA_INIT;
virCPUx86Data *data_disabled = NULL; virCPUx86Data data_disabled = VIR_CPU_X86_DATA_INIT;
virCPUx86Data *data_forbidden = NULL; virCPUx86Data data_forbidden = VIR_CPU_X86_DATA_INIT;
virCPUx86Data *data_vendor = NULL; virCPUx86Data data_vendor = VIR_CPU_X86_DATA_INIT;
if (forced) if (forced)
*forced = NULL; *forced = NULL;
@ -1783,35 +1757,25 @@ x86Encode(virArch arch,
if (!(map = virCPUx86GetMap())) if (!(map = virCPUx86GetMap()))
goto error; goto error;
if (forced) { if (forced &&
data_forced = x86EncodePolicy(cpu, map, VIR_CPU_FEATURE_FORCE); x86EncodePolicy(&data_forced, cpu, map, VIR_CPU_FEATURE_FORCE) < 0)
if (!data_forced) goto error;
goto error;
}
if (required) { if (required &&
data_required = x86EncodePolicy(cpu, map, VIR_CPU_FEATURE_REQUIRE); x86EncodePolicy(&data_required, cpu, map, VIR_CPU_FEATURE_REQUIRE) < 0)
if (!data_required) goto error;
goto error;
}
if (optional) { if (optional &&
data_optional = x86EncodePolicy(cpu, map, VIR_CPU_FEATURE_OPTIONAL); x86EncodePolicy(&data_optional, cpu, map, VIR_CPU_FEATURE_OPTIONAL) < 0)
if (!data_optional) goto error;
goto error;
}
if (disabled) { if (disabled &&
data_disabled = x86EncodePolicy(cpu, map, VIR_CPU_FEATURE_DISABLE); x86EncodePolicy(&data_disabled, cpu, map, VIR_CPU_FEATURE_DISABLE) < 0)
if (!data_disabled) goto error;
goto error;
}
if (forbidden) { if (forbidden &&
data_forbidden = x86EncodePolicy(cpu, map, VIR_CPU_FEATURE_FORBID); x86EncodePolicy(&data_forbidden, cpu, map, VIR_CPU_FEATURE_FORBID) < 0)
if (!data_forbidden) goto error;
goto error;
}
if (vendor) { if (vendor) {
virCPUx86VendorPtr v = NULL; virCPUx86VendorPtr v = NULL;
@ -1822,11 +1786,8 @@ x86Encode(virArch arch,
goto error; goto error;
} }
if (v && if (v && virCPUx86DataAddCPUID(&data_vendor, &v->cpuid) < 0)
(VIR_ALLOC(data_vendor) < 0 ||
virCPUx86DataAddCPUID(data_vendor, &v->cpuid) < 0)) {
goto error; goto error;
}
} }
if (forced && if (forced &&
@ -1851,12 +1812,12 @@ x86Encode(virArch arch,
return 0; return 0;
error: error:
virCPUx86DataFree(data_forced); virCPUx86DataClear(&data_forced);
virCPUx86DataFree(data_required); virCPUx86DataClear(&data_required);
virCPUx86DataFree(data_optional); virCPUx86DataClear(&data_optional);
virCPUx86DataFree(data_disabled); virCPUx86DataClear(&data_disabled);
virCPUx86DataFree(data_forbidden); virCPUx86DataClear(&data_forbidden);
virCPUx86DataFree(data_vendor); virCPUx86DataClear(&data_vendor);
if (forced) if (forced)
x86FreeCPUData(*forced); x86FreeCPUData(*forced);
if (required) if (required)
@ -1933,15 +1894,12 @@ static virCPUDataPtr
x86NodeData(virArch arch) x86NodeData(virArch arch)
{ {
virCPUDataPtr cpuData = NULL; virCPUDataPtr cpuData = NULL;
virCPUx86Data *data; virCPUx86Data data = VIR_CPU_X86_DATA_INIT;
if (VIR_ALLOC(data) < 0) if (cpuidSet(CPUX86_BASIC, &data) < 0)
return NULL;
if (cpuidSet(CPUX86_BASIC, data) < 0)
goto error; goto error;
if (cpuidSet(CPUX86_EXTENDED, data) < 0) if (cpuidSet(CPUX86_EXTENDED, &data) < 0)
goto error; goto error;
if (!(cpuData = virCPUx86MakeData(arch, &data))) if (!(cpuData = virCPUx86MakeData(arch, &data)))
@ -1950,7 +1908,7 @@ x86NodeData(virArch arch)
return cpuData; return cpuData;
error: error:
virCPUx86DataFree(data); virCPUx86DataClear(&data);
return NULL; return NULL;
} }
@ -2044,21 +2002,21 @@ x86Baseline(virCPUDefPtr *cpus,
} }
} }
x86DataIntersect(base_model->data, model->data); x86DataIntersect(&base_model->data, &model->data);
x86ModelFree(model); x86ModelFree(model);
model = NULL; model = NULL;
} }
if (x86DataIsEmpty(base_model->data)) { if (x86DataIsEmpty(&base_model->data)) {
virReportError(VIR_ERR_OPERATION_FAILED, virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("CPUs are incompatible")); "%s", _("CPUs are incompatible"));
goto error; goto error;
} }
if (vendor && virCPUx86DataAddCPUID(base_model->data, &vendor->cpuid) < 0) if (vendor && virCPUx86DataAddCPUID(&base_model->data, &vendor->cpuid) < 0)
goto error; goto error;
if (x86Decode(cpu, base_model->data, models, nmodels, modelName, flags) < 0) if (x86Decode(cpu, &base_model->data, models, nmodels, modelName, flags) < 0)
goto error; goto error;
if (STREQ_NULLABLE(cpu->model, modelName)) if (STREQ_NULLABLE(cpu->model, modelName))
@ -2105,7 +2063,7 @@ x86UpdateCustom(virCPUDefPtr guest,
goto cleanup; goto cleanup;
} }
if (x86DataIsSubset(host_model->data, feature->data)) if (x86DataIsSubset(&host_model->data, &feature->data))
guest->features[i].policy = VIR_CPU_FEATURE_REQUIRE; guest->features[i].policy = VIR_CPU_FEATURE_REQUIRE;
else else
guest->features[i].policy = VIR_CPU_FEATURE_DISABLE; guest->features[i].policy = VIR_CPU_FEATURE_DISABLE;
@ -2116,7 +2074,7 @@ x86UpdateCustom(virCPUDefPtr guest,
guest->match = VIR_CPU_MATCH_EXACT; guest->match = VIR_CPU_MATCH_EXACT;
if (x86ModelSubtractCPU(host_model, guest, map) || if (x86ModelSubtractCPU(host_model, guest, map) ||
x86DataToCPUFeatures(guest, VIR_CPU_FEATURE_REQUIRE, x86DataToCPUFeatures(guest, VIR_CPU_FEATURE_REQUIRE,
host_model->data, map)) &host_model->data, map))
goto cleanup; goto cleanup;
} }
@ -2222,7 +2180,7 @@ x86HasFeature(const virCPUData *data,
if (!(feature = x86FeatureFind(map, name))) if (!(feature = x86FeatureFind(map, name)))
goto cleanup; goto cleanup;
ret = x86DataIsSubset(data->data.x86, feature->data) ? 1 : 0; ret = x86DataIsSubset(&data->data.x86, &feature->data) ? 1 : 0;
cleanup: cleanup:
return ret; return ret;

4
src/cpu/cpu_x86.h
View File

@ -32,9 +32,9 @@ extern struct cpuArchDriver cpuDriverX86;
int virCPUx86DataAddCPUID(virCPUx86Data *data, int virCPUx86DataAddCPUID(virCPUx86Data *data,
const virCPUx86CPUID *cpuid); const virCPUx86CPUID *cpuid);
void virCPUx86DataFree(virCPUx86Data *data); void virCPUx86DataClear(virCPUx86Data *data);
virCPUDataPtr virCPUx86MakeData(virArch arch, virCPUDataPtr virCPUx86MakeData(virArch arch,
virCPUx86Data **data); virCPUx86Data *data);
#endif /* __VIR_CPU_X86_H__ */ #endif /* __VIR_CPU_X86_H__ */

2
src/cpu/cpu_x86_data.h
View File

@ -58,6 +58,8 @@ struct _virCPUx86CPUID {
# define VIR_CPU_x86_KVM_HV_RESET "__kvm_hv_reset" # define VIR_CPU_x86_KVM_HV_RESET "__kvm_hv_reset"
# define VIR_CPU_X86_DATA_INIT { 0 }
typedef struct _virCPUx86Data virCPUx86Data; typedef struct _virCPUx86Data virCPUx86Data;
struct _virCPUx86Data { struct _virCPUx86Data {
size_t len; size_t len;

2
src/libvirt_private.syms
View File

@ -942,7 +942,7 @@ cpuUpdate;
# cpu/cpu_x86.h # cpu/cpu_x86.h
virCPUx86DataAddCPUID; virCPUx86DataAddCPUID;
virCPUx86DataFree; virCPUx86DataClear;
virCPUx86MakeData; virCPUx86MakeData;

9
src/qemu/qemu_monitor_json.c
View File

@ -6407,7 +6407,7 @@ static int
qemuMonitorJSONParseCPUx86Features(virJSONValuePtr data, qemuMonitorJSONParseCPUx86Features(virJSONValuePtr data,
virCPUDataPtr *cpudata) virCPUDataPtr *cpudata)
{ {
virCPUx86Data *x86Data = NULL; virCPUx86Data x86Data = VIR_CPU_X86_DATA_INIT;
virCPUx86CPUID cpuid; virCPUx86CPUID cpuid;
size_t i; size_t i;
ssize_t n; ssize_t n;
@ -6419,13 +6419,10 @@ qemuMonitorJSONParseCPUx86Features(virJSONValuePtr data,
return -1; return -1;
} }
if (VIR_ALLOC(x86Data) < 0)
return -1;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
if (qemuMonitorJSONParseCPUx86FeatureWord(virJSONValueArrayGet(data, i), if (qemuMonitorJSONParseCPUx86FeatureWord(virJSONValueArrayGet(data, i),
&cpuid) < 0 || &cpuid) < 0 ||
virCPUx86DataAddCPUID(x86Data, &cpuid) < 0) virCPUx86DataAddCPUID(&x86Data, &cpuid) < 0)
goto cleanup; goto cleanup;
} }
@ -6435,7 +6432,7 @@ qemuMonitorJSONParseCPUx86Features(virJSONValuePtr data,
ret = 0; ret = 0;
cleanup: cleanup:
virCPUx86DataFree(x86Data); virCPUx86DataClear(&x86Data);
return ret; return ret;
} }