/**
* cpuGetModels:
*
* @archName: CPU architecture string
* @models: where to store the list of supported models
*
* Fetches all CPU models supported by libvirt on @archName.
*
* Returns number of supported CPU models or -1 on error.
*/
int
cpuGetModels(const char *archName, char ***models)
{
struct cpuArchDriver *driver;
virArch arch;
VIR_DEBUG("arch=%s", archName);
arch = virArchFromString(archName);
if (arch == VIR_ARCH_NONE) {
virReportError(VIR_ERR_INVALID_ARG,
_("cannot find architecture %s"),
archName);
return -1;
}
driver = cpuGetSubDriver(arch);
if (driver == NULL) {
virReportError(VIR_ERR_INVALID_ARG,
_("cannot find a driver for the architecture %s"),
archName);
return -1;
}
if (!driver->getModels) {
virReportError(VIR_ERR_NO_SUPPORT,
_("CPU driver for %s has no CPU model support"),
virArchToString(arch));
return -1;
}
return driver->getModels(models);
}
/**
* cpuGuestData:
*
* @host: host CPU definition
* @guest: guest CPU definition
* @data: computed guest CPU data
* @msg: error message describing why the @guest and @host CPUs are considered
* incompatible
*
* Computes guest CPU data for the @guest CPU definition when run on the @host
* CPU.
*
* Returns VIR_CPU_COMPARE_ERROR on error, VIR_CPU_COMPARE_INCOMPATIBLE when
* the two CPUs are incompatible (@msg will describe the incompatibility),
* VIR_CPU_COMPARE_IDENTICAL when the two CPUs are identical,
* VIR_CPU_COMPARE_SUPERSET when the @guest CPU is a superset of the @host CPU.
*/
virCPUCompareResult
cpuGuestData(virCPUDefPtr host,
virCPUDefPtr guest,
virCPUDataPtr *data,
char **msg)
{
struct cpuArchDriver *driver;
VIR_DEBUG("host=%p, guest=%p, data=%p, msg=%p", host, guest, data, msg);
if (!guest->model) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("no guest CPU model specified"));
return VIR_CPU_COMPARE_ERROR;
}
if ((driver = cpuGetSubDriver(host->arch)) == NULL)
return VIR_CPU_COMPARE_ERROR;
if (driver->guestData == NULL) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot compute guest CPU data for %s architecture"),
virArchToString(host->arch));
return VIR_CPU_COMPARE_ERROR;
}
return driver->guestData(host, guest, data, msg);
}
/**
* virCPUUpdateLive:
*
* @arch: CPU architecture
* @cpu: guest CPU definition to be updated
* @dataEnabled: CPU data of the virtual CPU
* @dataDisabled: CPU data with features requested by @cpu but disabled by the
* hypervisor
*
* Update custom mode CPU according to the virtual CPU created by the
* hypervisor. The function refuses to update the CPU in case cpu->check is set
* to VIR_CPU_CHECK_FULL.
*
* Returns -1 on error,
* 0 when the CPU was successfully updated,
* 1 when the operation does not make sense on the CPU or it is not
* supported for the given architecture.
*/
int
virCPUUpdateLive(virArch arch,
virCPUDefPtr cpu,
virCPUDataPtr dataEnabled,
virCPUDataPtr dataDisabled)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, cpu=%p, dataEnabled=%p, dataDisabled=%p",
virArchToString(arch), cpu, dataEnabled, dataDisabled);
if (!(driver = cpuGetSubDriver(arch)))
return -1;
if (!driver->updateLive)
return 1;
if (cpu->mode != VIR_CPU_MODE_CUSTOM)
return 1;
if (driver->updateLive(cpu, dataEnabled, dataDisabled) < 0)
return -1;
return 0;
}
int
cpuEncode(const char *arch,
const virCPUDefPtr cpu,
union cpuData **forced,
union cpuData **required,
union cpuData **optional,
union cpuData **disabled,
union cpuData **forbidden,
union cpuData **vendor)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, cpu=%p, forced=%p, required=%p, "
"optional=%p, disabled=%p, forbidden=%p, vendor=%p",
NULLSTR(arch), cpu, forced, required,
optional, disabled, forbidden, vendor);
if ((driver = cpuGetSubDriver(arch)) == NULL)
return -1;
if (driver->encode == NULL) {
virCPUReportError(VIR_ERR_NO_SUPPORT,
_("cannot encode CPU data for %s architecture"),
arch);
return -1;
}
return driver->encode(cpu, forced, required,
optional, disabled, forbidden, vendor);
}
/**
* cpuDecode:
*
* @cpu: CPU definition stub to be filled in
* @data: internal CPU data to be decoded into @cpu definition
* @models: list of CPU models that can be considered when decoding @data
*
* Decodes internal CPU data into a CPU definition consisting of a CPU model
* and a list of CPU features. The @cpu model stub is supposed to have arch,
* type, match and fallback members set, this function will add the rest. If
* @models list is NULL, all models supported by libvirt will be considered
* when decoding the data. In general, this function will select the model
* closest to the CPU specified by @data.
*
* For VIR_ARCH_I686 and VIR_ARCH_X86_64 architectures this means the computed
* CPU definition will have the shortest possible list of additional features.
*
* Returns 0 on success, -1 on error.
*/
int
cpuDecode(virCPUDefPtr cpu,
const virCPUData *data,
virDomainCapsCPUModelsPtr models)
{
struct cpuArchDriver *driver;
VIR_DEBUG("cpu=%p, data=%p, models=%p", cpu, data, models);
if (models) {
size_t i;
for (i = 0; i < models->nmodels; i++)
VIR_DEBUG("models[%zu]=%s", i, models->models[i].name);
}
if (cpu->type > VIR_CPU_TYPE_GUEST ||
cpu->mode != VIR_CPU_MODE_CUSTOM) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("invalid CPU definition stub"));
return -1;
}
if ((driver = cpuGetSubDriver(data->arch)) == NULL)
return -1;
if (driver->decode == NULL) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot decode CPU data for %s architecture"),
virArchToString(cpu->arch));
return -1;
}
return driver->decode(cpu, data, models);
}
/**
* cpuCompare:
*
* @host: host CPU definition
* @cpu: either guest or host CPU to be compared with @host
*
* Compares the CPU described by @cpu with @host CPU.
*
* Returns VIR_CPU_COMPARE_ERROR on error, VIR_CPU_COMPARE_INCOMPATIBLE when
* the two CPUs are incompatible, VIR_CPU_COMPARE_IDENTICAL when the two CPUs
* are identical, VIR_CPU_COMPARE_SUPERSET when the @cpu CPU is a superset of
* the @host CPU.
*/
virCPUCompareResult
cpuCompare(virCPUDefPtr host,
virCPUDefPtr cpu,
bool failIncompatible)
{
struct cpuArchDriver *driver;
VIR_DEBUG("host=%p, cpu=%p", host, cpu);
if (!cpu->model) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("no guest CPU model specified"));
return VIR_CPU_COMPARE_ERROR;
}
if ((driver = cpuGetSubDriver(host->arch)) == NULL)
return VIR_CPU_COMPARE_ERROR;
if (driver->compare == NULL) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot compare CPUs of %s architecture"),
virArchToString(host->arch));
return VIR_CPU_COMPARE_ERROR;
}
return driver->compare(host, cpu, failIncompatible);
}
/**
* virCPUGetHostIsSupported:
*
* @arch: CPU architecture
*
* Check whether virCPUGetHost is supported for @arch.
*
* Returns true if virCPUGetHost is supported, false otherwise.
*/
bool
virCPUGetHostIsSupported(virArch arch)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s", virArchToString(arch));
return (driver = cpuGetSubDriver(arch)) && driver->getHost;
}
/**
* cpuBaseline:
*
* @cpus: list of host CPU definitions
* @ncpus: number of CPUs in @cpus
* @models: list of CPU models that can be considered for the baseline CPU
* @migratable: requests non-migratable features to be removed from the result
*
* Computes the most feature-rich CPU which is compatible with all given
* host CPUs. If @models is NULL, all models supported by libvirt will
* be considered when computing the baseline CPU model, otherwise the baseline
* CPU model will be one of the provided CPU @models.
*
* Returns baseline CPU definition or NULL on error.
*/
virCPUDefPtr
cpuBaseline(virCPUDefPtr *cpus,
unsigned int ncpus,
virDomainCapsCPUModelsPtr models,
bool migratable)
{
struct cpuArchDriver *driver;
size_t i;
VIR_DEBUG("ncpus=%u, models=%p, migratable=%d", ncpus, models, migratable);
if (cpus) {
for (i = 0; i < ncpus; i++)
VIR_DEBUG("cpus[%zu]=%p", i, cpus[i]);
}
if (models) {
for (i = 0; i < models->nmodels; i++)
VIR_DEBUG("models[%zu]=%s", i, models->models[i].name);
}
if (cpus == NULL && ncpus != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("nonzero ncpus doesn't match with NULL cpus"));
return NULL;
}
if (ncpus < 1) {
virReportError(VIR_ERR_INVALID_ARG, "%s", _("No CPUs given"));
return NULL;
}
for (i = 0; i < ncpus; i++) {
if (!cpus[i]) {
virReportError(VIR_ERR_INVALID_ARG,
_("invalid CPU definition at index %zu"), i);
return NULL;
}
if (!cpus[i]->model) {
virReportError(VIR_ERR_INVALID_ARG,
_("no CPU model specified at index %zu"), i);
return NULL;
}
}
if ((driver = cpuGetSubDriver(cpus[0]->arch)) == NULL)
return NULL;
if (driver->baseline == NULL) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot compute baseline CPU of %s architecture"),
virArchToString(cpus[0]->arch));
return NULL;
}
return driver->baseline(cpus, ncpus, models, migratable);
}
/**
* virCPUUpdate:
*
* @arch: CPU architecture
* @guest: guest CPU definition to be updated
* @host: host CPU definition
*
* Updates @guest CPU definition according to @host CPU. This is required to
* support guest CPU definitions specified relatively to host CPU, such as
* CPUs with VIR_CPU_MODE_CUSTOM and optional features or
* VIR_CPU_MATCH_MINIMUM, or CPUs with VIR_CPU_MODE_HOST_MODEL.
* When the guest CPU was not specified relatively, the function does nothing
* and returns success.
*
* Returns 0 on success, -1 on error.
*/
int
virCPUUpdate(virArch arch,
virCPUDefPtr guest,
const virCPUDef *host)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, guest=%p mode=%s model=%s, host=%p model=%s",
virArchToString(arch), guest, virCPUModeTypeToString(guest->mode),
NULLSTR(guest->model), host, NULLSTR(host ? host->model : NULL));
if (!(driver = cpuGetSubDriver(arch)))
return -1;
if (guest->mode == VIR_CPU_MODE_HOST_PASSTHROUGH)
return 0;
if (guest->mode == VIR_CPU_MODE_CUSTOM &&
guest->match != VIR_CPU_MATCH_MINIMUM) {
size_t i;
bool optional = false;
for (i = 0; i < guest->nfeatures; i++) {
if (guest->features[i].policy == VIR_CPU_FEATURE_OPTIONAL) {
optional = true;
break;
}
}
if (!optional)
return 0;
}
/* We get here if guest CPU is either
* - host-model
* - custom with minimum match
* - custom with optional features
*/
if (!driver->update) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot update guest CPU for %s architecture"),
virArchToString(arch));
return -1;
}
if (driver->update(guest, host) < 0)
return -1;
VIR_DEBUG("model=%s", NULLSTR(guest->model));
return 0;
}
/**
* virCPUDataFree:
*
* @data: CPU data structure to be freed
*
* Free internal CPU data.
*
* Returns nothing.
*/
void
virCPUDataFree(virCPUDataPtr data)
{
struct cpuArchDriver *driver;
VIR_DEBUG("data=%p", data);
if (!data)
return;
if ((driver = cpuGetSubDriver(data->arch)) && driver->dataFree)
driver->dataFree(data);
else
VIR_FREE(data);
}
virCPUDefPtr
cpuBaseline(virCPUDefPtr *cpus,
unsigned int ncpus,
const char **models,
unsigned int nmodels)
{
struct cpuArchDriver *driver;
unsigned int i;
VIR_DEBUG("ncpus=%u, nmodels=%u", ncpus, nmodels);
if (cpus) {
for (i = 0; i < ncpus; i++)
VIR_DEBUG("cpus[%u]=%p", i, cpus[i]);
}
if (models) {
for (i = 0; i < nmodels; i++)
VIR_DEBUG("models[%u]=%s", i, NULLSTR(models[i]));
}
if (cpus == NULL && ncpus != 0) {
virCPUReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("nonzero ncpus doesn't match with NULL cpus"));
return NULL;
}
if (ncpus < 1) {
virCPUReportError(VIR_ERR_INVALID_ARG, "%s", _("No CPUs given"));
return NULL;
}
if (models == NULL && nmodels != 0) {
virCPUReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("nonzero nmodels doesn't match with NULL models"));
return NULL;
}
if ((driver = cpuGetSubDriver(cpus[0]->arch)) == NULL)
return NULL;
if (driver->baseline == NULL) {
virCPUReportError(VIR_ERR_NO_SUPPORT,
_("cannot compute baseline CPU of %s architecture"),
cpus[0]->arch);
return NULL;
}
return driver->baseline(cpus, ncpus, models, nmodels);
}
/**
* virCPUCopyMigratable:
*
* @arch: CPU architecture
* @cpu: CPU definition to be copied
*
* Makes a copy of @cpu with all features which would block migration removed.
* If this doesn't make sense for a given architecture, the function returns a
* plain copy of @cpu (i.e., a copy with no features removed).
*
* Returns the copy of the CPU or NULL on error.
*/
virCPUDefPtr
virCPUCopyMigratable(virArch arch,
virCPUDefPtr cpu)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, cpu=%p, model=%s",
virArchToString(arch), cpu, NULLSTR(cpu->model));
if (!(driver = cpuGetSubDriver(arch)))
return NULL;
if (driver->copyMigratable)
return driver->copyMigratable(cpu);
else
return virCPUDefCopy(cpu);
}
/**
* virCPUValidateFeatures:
*
* @arch: CPU architecture
* @cpu: CPU definition to be checked
*
* Checks whether all CPU features specified in @cpu are valid.
*
* Returns 0 on success (all features are valid), -1 on error.
*/
int
virCPUValidateFeatures(virArch arch,
virCPUDefPtr cpu)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, cpu=%p, nfeatures=%zu",
virArchToString(arch), cpu, cpu->nfeatures);
if (!(driver = cpuGetSubDriver(arch)))
return -1;
if (driver->validateFeatures)
return driver->validateFeatures(cpu);
else
return 0;
}
/**
* virCPUGetModels:
*
* @arch: CPU architecture
* @models: where to store the NULL-terminated list of supported models
*
* Fetches all CPU models supported by libvirt on @archName. If there are
* no restrictions on CPU models on @archName (i.e., the CPU model is just
* passed directly to a hypervisor), this function returns 0 and sets
* @models to NULL.
*
* Returns number of supported CPU models, 0 if any CPU model is supported,
* or -1 on error.
*/
int
virCPUGetModels(virArch arch, char ***models)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s", virArchToString(arch));
if (!(driver = cpuGetSubDriver(arch)))
return -1;
if (!driver->getModels) {
if (models)
*models = NULL;
return 0;
}
return driver->getModels(models);
}
union cpuData *
cpuNodeData(const char *arch)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s", NULLSTR(arch));
if ((driver = cpuGetSubDriver(arch)) == NULL)
return NULL;
if (driver->nodeData == NULL) {
virCPUReportError(VIR_ERR_NO_SUPPORT,
_("cannot get node CPU data for %s architecture"),
arch);
return NULL;
}
return driver->nodeData();
}
/**
* cpuDataFormat:
*
* @data: internal CPU representation
*
* Formats @data into XML for test purposes.
*
* Returns string representation of the XML describing @data or NULL on error.
*/
char *
cpuDataFormat(const virCPUData *data)
{
struct cpuArchDriver *driver;
VIR_DEBUG("data=%p", data);
if (!(driver = cpuGetSubDriver(data->arch)))
return NULL;
if (!driver->dataFormat) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot format %s CPU data"),
virArchToString(data->arch));
return NULL;
}
return driver->dataFormat(data);
}
/**
* cpuNodeData:
*
* @arch: CPU architecture
*
* Returns CPU data for host CPU or NULL on error.
*/
virCPUDataPtr
cpuNodeData(virArch arch)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s", virArchToString(arch));
if ((driver = cpuGetSubDriver(arch)) == NULL)
return NULL;
if (driver->nodeData == NULL) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot get node CPU data for %s architecture"),
virArchToString(arch));
return NULL;
}
return driver->nodeData(arch);
}
/**
* cpuDecode:
*
* @cpu: CPU definition stub to be filled in
* @data: internal CPU data to be decoded into @cpu definition
* @models: list of CPU models that can be considered when decoding @data
* @nmodels: number of CPU models in @models
* @preferred: CPU models that should be used if possible
*
* Decodes internal CPU data into a CPU definition consisting of a CPU model
* and a list of CPU features. The @cpu model stub is supposed to have arch,
* type, match and fallback members set, this function will add the rest. If
* @models list is NULL, all models supported by libvirt will be considered
* when decoding the data. In general, this function will select the model
* closest to the CPU specified by @data unless @preferred is non-NULL, in
* which case the @preferred model will be used as long as it is compatible
* with @data.
*
* For VIR_ARCH_I686 and VIR_ARCH_X86_64 architectures this means the computed
* CPU definition will have the shortest possible list of additional features.
* When @preferred is non-NULL, the @preferred model will be used even if
* other models would result in a shorter list of additional features.
*
* Returns 0 on success, -1 on error.
*/
int
cpuDecode(virCPUDefPtr cpu,
const virCPUData *data,
const char **models,
unsigned int nmodels,
const char *preferred)
{
struct cpuArchDriver *driver;
VIR_DEBUG("cpu=%p, data=%p, nmodels=%u, preferred=%s",
cpu, data, nmodels, NULLSTR(preferred));
if (models) {
size_t i;
for (i = 0; i < nmodels; i++)
VIR_DEBUG("models[%zu]=%s", i, NULLSTR(models[i]));
}
if (models == NULL && nmodels != 0) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("nonzero nmodels doesn't match with NULL models"));
return -1;
}
if (cpu->type > VIR_CPU_TYPE_GUEST ||
cpu->mode != VIR_CPU_MODE_CUSTOM) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("invalid CPU definition stub"));
return -1;
}
if ((driver = cpuGetSubDriver(cpu->arch)) == NULL)
return -1;
if (driver->decode == NULL) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot decode CPU data for %s architecture"),
virArchToString(cpu->arch));
return -1;
}
return driver->decode(cpu, data, models, nmodels, preferred, 0);
}
virCPUCompareResult
cpuCompare(virCPUDefPtr host,
virCPUDefPtr cpu)
{
struct cpuArchDriver *driver;
VIR_DEBUG("host=%p, cpu=%p", host, cpu);
if ((driver = cpuGetSubDriver(host->arch)) == NULL)
return VIR_CPU_COMPARE_ERROR;
if (driver->compare == NULL) {
virCPUReportError(VIR_ERR_NO_SUPPORT,
_("cannot compare CPUs of %s architecture"),
host->arch);
return VIR_CPU_COMPARE_ERROR;
}
return driver->compare(host, cpu);
}
/**
* cpuDataParse:
*
* @arch: CPU architecture
* @xmlStr: XML string produced by cpuDataFormat
*
* Parses XML representation of virCPUData structure for test purposes.
*
* Returns internal CPU data structure parsed from the XML or NULL on error.
*/
virCPUDataPtr
cpuDataParse(virArch arch,
const char *xmlStr)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, xmlStr=%s", virArchToString(arch), xmlStr);
if (!(driver = cpuGetSubDriver(arch)))
return NULL;
if (!driver->dataParse) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot parse %s CPU data"),
virArchToString(arch));
return NULL;
}
return driver->dataParse(xmlStr);
}
/**
* cpuHasFeature:
*
* @data: internal CPU representation
* @feature: feature to be checked for
*
* Checks whether @feature is supported by the CPU described by @data.
*
* Returns 1 if the feature is supported, 0 if it's not supported, or
* -1 on error.
*/
int
cpuHasFeature(const virCPUData *data,
const char *feature)
{
struct cpuArchDriver *driver;
VIR_DEBUG("data=%p, feature=%s", data, feature);
if ((driver = cpuGetSubDriver(data->arch)) == NULL)
return -1;
if (driver->hasFeature == NULL) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot check guest CPU data for %s architecture"),
virArchToString(data->arch));
return -1;
}
return driver->hasFeature(data, feature);
}
int
cpuUpdate(virCPUDefPtr guest,
const virCPUDefPtr host)
{
struct cpuArchDriver *driver;
VIR_DEBUG("guest=%p, host=%p", guest, host);
if ((driver = cpuGetSubDriver(host->arch)) == NULL)
return -1;
if (driver->update == NULL) {
virCPUReportError(VIR_ERR_NO_SUPPORT,
_("cannot update guest CPU data for %s architecture"),
host->arch);
return -1;
}
return driver->update(guest, host);
}
int
cpuDecode(virCPUDefPtr cpu,
const union cpuData *data,
const char **models,
unsigned int nmodels,
const char *preferred)
{
struct cpuArchDriver *driver;
VIR_DEBUG("cpu=%p, data=%p, nmodels=%u, preferred=%s",
cpu, data, nmodels, NULLSTR(preferred));
if (models) {
unsigned int i;
for (i = 0; i < nmodels; i++)
VIR_DEBUG("models[%u]=%s", i, NULLSTR(models[i]));
}
if (models == NULL && nmodels != 0) {
virCPUReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("nonzero nmodels doesn't match with NULL models"));
return -1;
}
if (cpu == NULL) {
virCPUReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("invalid CPU definition"));
return -1;
}
if ((driver = cpuGetSubDriver(cpu->arch)) == NULL)
return -1;
if (driver->decode == NULL) {
virCPUReportError(VIR_ERR_NO_SUPPORT,
_("cannot decode CPU data for %s architecture"),
cpu->arch);
return -1;
}
return driver->decode(cpu, data, models, nmodels, preferred);
}
/**
* virCPUDataCheckFeature:
*
* @data: CPU data
* @feature: feature to be checked for
*
* Checks whether @feature is supported by the CPU described by @data.
*
* Returns 1 if the feature is supported, 0 if it's not supported, or
* -1 on error.
*/
int
virCPUDataCheckFeature(const virCPUData *data,
const char *feature)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, data=%p, feature=%s",
virArchToString(data->arch), data, feature);
if (!(driver = cpuGetSubDriver(data->arch)))
return -1;
if (!driver->dataCheckFeature) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot check guest CPU feature for %s architecture"),
virArchToString(data->arch));
return -1;
}
return driver->dataCheckFeature(data, feature);
}
virCPUCompareResult
cpuGuestData(virCPUDefPtr host,
virCPUDefPtr guest,
union cpuData **data)
{
struct cpuArchDriver *driver;
VIR_DEBUG("host=%p, guest=%p, data=%p", host, guest, data);
if ((driver = cpuGetSubDriver(host->arch)) == NULL)
return VIR_CPU_COMPARE_ERROR;
if (driver->guestData == NULL) {
virCPUReportError(VIR_ERR_NO_SUPPORT,
_("cannot compute guest CPU data for %s architecture"),
host->arch);
return VIR_CPU_COMPARE_ERROR;
}
return driver->guestData(host, guest, data);
}
/**
* virCPUConvertLegacy:
*
* @arch: CPU architecture
* @cpu: CPU definition to be converted
*
* Convert legacy CPU definition into one that the corresponding cpu driver
* will be able to work with. Currently this is only implemented by the PPC
* driver, which needs to convert legacy POWERx_v* names into POWERx.
*
* Returns -1 on error, 0 on success.
*/
int
virCPUConvertLegacy(virArch arch,
virCPUDefPtr cpu)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, cpu=%p, model=%s",
virArchToString(arch), cpu, NULLSTR(cpu->model));
if (!(driver = cpuGetSubDriver(arch)))
return -1;
if (!driver->convertLegacy)
return 0;
if (driver->convertLegacy(cpu) < 0)
return -1;
VIR_DEBUG("model=%s", NULLSTR(cpu->model));
return 0;
}
/**
* virCPUTranslate:
*
* @arch: CPU architecture
* @cpu: CPU definition to be translated
* @models: list of allowed CPU models (NULL if all are allowed)
*
* Translates @cpu model (if allowed by @cpu->fallback) to a closest CPU model
* from @models list.
*
* The function does nothing (and returns 0) if @cpu does not have to be
* translated.
*
* Returns -1 on error, 0 on success.
*/
int
virCPUTranslate(virArch arch,
virCPUDefPtr cpu,
virDomainCapsCPUModelsPtr models)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, cpu=%p, model=%s, models=%p",
virArchToString(arch), cpu, NULLSTR(cpu->model), models);
if (!(driver = cpuGetSubDriver(arch)))
return -1;
if (cpu->mode == VIR_CPU_MODE_HOST_MODEL ||
cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH)
return 0;
if (virCPUModelIsAllowed(cpu->model, models))
return 0;
if (cpu->fallback != VIR_CPU_FALLBACK_ALLOW) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("CPU model %s is not supported by hypervisor"),
cpu->model);
return -1;
}
if (!driver->translate) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot translate CPU model %s to a supported model"),
cpu->model);
return -1;
}
if (driver->translate(cpu, models) < 0)
return -1;
VIR_DEBUG("model=%s", NULLSTR(cpu->model));
return 0;
}
/**
* virCPUExpandFeatures:
*
* @arch: CPU architecture
* @cpu: CPU definition to be expanded
*
* Add all features implicitly enabled by the CPU model to the list of
* features. The @cpu is expected to be either a host or a guest representation
* of a host CPU, i.e., only VIR_CPU_FEATURE_REQUIRE and
* VIR_CPU_FEATURE_DISABLE policies are supported.
*
* The updated list of features in the CPU definition is sorted.
*
* Return -1 on error, 0 on success.
*/
int
virCPUExpandFeatures(virArch arch,
virCPUDefPtr cpu)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, cpu=%p, model=%s, nfeatures=%zu",
virArchToString(arch), cpu, NULLSTR(cpu->model), cpu->nfeatures);
if (!(driver = cpuGetSubDriver(arch)))
return -1;
if (driver->expandFeatures &&
driver->expandFeatures(cpu) < 0)
return -1;
qsort(cpu->features, cpu->nfeatures, sizeof(*cpu->features),
virCPUFeatureCompare);
VIR_DEBUG("nfeatures=%zu", cpu->nfeatures);
return 0;
}
int
cpuHasFeature(const char *arch,
const union cpuData *data,
const char *feature)
{
struct cpuArchDriver *driver;
VIR_DEBUG("arch=%s, data=%p, feature=%s",
arch, data, feature);
if ((driver = cpuGetSubDriver(arch)) == NULL)
return -1;
if (driver->hasFeature == NULL) {
virCPUReportError(VIR_ERR_NO_SUPPORT,
_("cannot check guest CPU data for %s architecture"),
arch);
return -1;
}
return driver->hasFeature(data, feature);
}
/**
* cpuDataFree:
*
* @data: CPU data structure to be freed
*
* Free internal CPU data.
*
* Returns nothing.
*/
void
cpuDataFree(virCPUDataPtr data)
{
struct cpuArchDriver *driver;
VIR_DEBUG("data=%p", data);
if (data == NULL)
return;
if ((driver = cpuGetSubDriver(data->arch)) == NULL)
return;
if (driver->free == NULL) {
virReportError(VIR_ERR_NO_SUPPORT,
_("cannot free CPU data for %s architecture"),
virArchToString(data->arch));
return;
}
(driver->free)(data);
}
