2011-10-03 12:56:20 +00:00
|
|
|
/*
|
2015-07-20 12:35:22 +00:00
|
|
|
* cpu_ppc64.c: CPU driver for 64-bit PowerPC CPUs
|
2011-10-03 12:56:20 +00:00
|
|
|
*
|
maint: avoid 'const fooPtr' in cpu files
'const fooPtr' is the same as 'foo * const' (the pointer won't
change, but it's contents can). But in general, if an interface
is trying to be const-correct, it should be using 'const foo *'
(the pointer is to data that can't be changed).
Fix up offenders in src/cpu.
* src/cpu/cpu.h (cpuArchDecode, cpuArchEncode, cpuArchUpdate)
(cpuArchHasFeature, cpuDecode, cpuEncode, cpuUpdate)
(cpuHasFeature): Use intended type.
* src/conf/cpu_conf.h (virCPUDefCopyModel, virCPUDefCopy):
Likewise.
(virCPUDefParseXML): Drop const.
* src/cpu/cpu.c (cpuDecode, cpuEncode, cpuUpdate, cpuHasFeature):
Fix fallout.
* src/cpu/cpu_x86.c (x86ModelFromCPU, x86ModelSubtractCPU)
(x86DecodeCPUData, x86EncodePolicy, x86Encode, x86UpdateCustom)
(x86UpdateHostModel, x86Update, x86HasFeature): Likewise.
* src/cpu/cpu_s390.c (s390Decode): Likewise.
* src/cpu/cpu_arm.c (ArmDecode): Likewise.
* src/cpu/cpu_powerpc.c (ppcModelFromCPU, ppcCompute, ppcDecode)
(ppcUpdate): Likewise.
* src/conf/cpu_conf.c (virCPUDefCopyModel, virCPUDefCopy)
(virCPUDefParseXML): Likewise.
Signed-off-by: Eric Blake <eblake@redhat.com>
2013-10-05 20:01:02 +00:00
|
|
|
* Copyright (C) 2013 Red Hat, Inc.
|
2012-10-15 09:07:51 +00:00
|
|
|
* Copyright (C) IBM Corporation, 2010
|
2011-10-03 12:56:20 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-21 10:06:23 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2011-10-03 12:56:20 +00:00
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anton Blanchard <anton@au.ibm.com>
|
|
|
|
* Prerna Saxena <prerna@linux.vnet.ibm.com>
|
2012-10-15 09:07:50 +00:00
|
|
|
* Li Zhang <zhlcindy@linux.vnet.ibm.com>
|
2011-10-03 12:56:20 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
2012-10-15 09:07:50 +00:00
|
|
|
#include <stdint.h>
|
2011-10-03 12:56:20 +00:00
|
|
|
|
2012-12-12 17:59:27 +00:00
|
|
|
#include "virlog.h"
|
2012-12-12 18:06:53 +00:00
|
|
|
#include "viralloc.h"
|
2011-10-03 12:56:20 +00:00
|
|
|
#include "cpu.h"
|
2013-05-03 12:41:23 +00:00
|
|
|
#include "virstring.h"
|
2012-10-15 09:07:50 +00:00
|
|
|
#include "cpu_map.h"
|
2012-12-04 12:04:07 +00:00
|
|
|
#include "virbuffer.h"
|
2011-10-03 12:56:20 +00:00
|
|
|
|
|
|
|
#define VIR_FROM_THIS VIR_FROM_CPU
|
|
|
|
|
2015-07-20 12:35:22 +00:00
|
|
|
VIR_LOG_INIT("cpu.cpu_ppc64");
|
2014-02-28 12:16:17 +00:00
|
|
|
|
2014-11-04 17:21:26 +00:00
|
|
|
static const virArch archs[] = { VIR_ARCH_PPC64, VIR_ARCH_PPC64LE };
|
2011-10-03 12:56:20 +00:00
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_vendor {
|
2012-10-15 09:07:50 +00:00
|
|
|
char *name;
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_vendor *next;
|
2012-10-15 09:07:50 +00:00
|
|
|
};
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_model {
|
2012-10-15 09:07:50 +00:00
|
|
|
char *name;
|
2015-07-20 13:13:02 +00:00
|
|
|
const struct ppc64_vendor *vendor;
|
2015-07-20 12:35:22 +00:00
|
|
|
struct cpuPPC64Data data;
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_model *next;
|
2012-10-15 09:07:50 +00:00
|
|
|
};
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_map {
|
|
|
|
struct ppc64_vendor *vendors;
|
|
|
|
struct ppc64_model *models;
|
2012-10-15 09:07:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64ModelFree(struct ppc64_model *model)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
|
|
|
if (model == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
VIR_FREE(model->name);
|
|
|
|
VIR_FREE(model);
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
static struct ppc64_model *
|
|
|
|
ppc64ModelFind(const struct ppc64_map *map,
|
|
|
|
const char *name)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_model *model;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
|
|
|
model = map->models;
|
|
|
|
while (model != NULL) {
|
|
|
|
if (STREQ(model->name, name))
|
|
|
|
return model;
|
|
|
|
|
|
|
|
model = model->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
static struct ppc64_model *
|
|
|
|
ppc64ModelFindPVR(const struct ppc64_map *map,
|
|
|
|
uint32_t pvr)
|
2012-12-19 00:35:51 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_model *model;
|
2012-12-19 00:35:51 +00:00
|
|
|
|
|
|
|
model = map->models;
|
|
|
|
while (model != NULL) {
|
|
|
|
if (model->data.pvr == pvr)
|
|
|
|
return model;
|
|
|
|
|
|
|
|
model = model->next;
|
|
|
|
}
|
|
|
|
|
2014-11-04 17:28:33 +00:00
|
|
|
/* PowerPC Processor Version Register is interpreted as follows :
|
|
|
|
* Higher order 16 bits : Power ISA generation.
|
|
|
|
* Lower order 16 bits : CPU chip version number.
|
2015-03-19 15:53:00 +00:00
|
|
|
* If the exact CPU isn't found, return the nearest matching CPU generation
|
2014-11-04 17:28:33 +00:00
|
|
|
*/
|
|
|
|
if (pvr & 0x0000FFFFul)
|
2015-07-20 13:13:02 +00:00
|
|
|
return ppc64ModelFindPVR(map, (pvr & 0xFFFF0000ul));
|
2014-11-04 17:28:33 +00:00
|
|
|
|
2012-12-19 00:35:51 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
static struct ppc64_model *
|
|
|
|
ppc64ModelCopy(const struct ppc64_model *model)
|
2013-09-03 06:28:24 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_model *copy;
|
2013-09-03 06:28:24 +00:00
|
|
|
|
|
|
|
if (VIR_ALLOC(copy) < 0 ||
|
|
|
|
VIR_STRDUP(copy->name, model->name) < 0) {
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64ModelFree(copy);
|
2013-09-03 06:28:24 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
copy->data.pvr = model->data.pvr;
|
|
|
|
copy->vendor = model->vendor;
|
|
|
|
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
static struct ppc64_vendor *
|
|
|
|
ppc64VendorFind(const struct ppc64_map *map,
|
|
|
|
const char *name)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_vendor *vendor;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
|
|
|
vendor = map->vendors;
|
|
|
|
while (vendor) {
|
|
|
|
if (STREQ(vendor->name, name))
|
|
|
|
return vendor;
|
|
|
|
|
|
|
|
vendor = vendor->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64VendorFree(struct ppc64_vendor *vendor)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
|
|
|
if (!vendor)
|
|
|
|
return;
|
|
|
|
|
|
|
|
VIR_FREE(vendor->name);
|
|
|
|
VIR_FREE(vendor);
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
static struct ppc64_model *
|
|
|
|
ppc64ModelFromCPU(const virCPUDef *cpu,
|
|
|
|
const struct ppc64_map *map)
|
2013-09-03 06:28:24 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_model *model = NULL;
|
2013-09-03 06:28:24 +00:00
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if ((model = ppc64ModelFind(map, cpu->model)) == NULL) {
|
2013-09-03 06:28:24 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Unknown CPU model %s"), cpu->model);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if ((model = ppc64ModelCopy(model)) == NULL)
|
2013-09-03 06:28:24 +00:00
|
|
|
goto error;
|
|
|
|
|
|
|
|
return model;
|
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
error:
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64ModelFree(model);
|
2013-09-03 06:28:24 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-10-15 09:07:50 +00:00
|
|
|
static int
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64VendorLoad(xmlXPathContextPtr ctxt,
|
|
|
|
struct ppc64_map *map)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_vendor *vendor = NULL;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2013-07-04 10:03:29 +00:00
|
|
|
if (VIR_ALLOC(vendor) < 0)
|
2012-12-18 23:06:45 +00:00
|
|
|
return -1;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
|
|
|
vendor->name = virXPathString("string(@name)", ctxt);
|
|
|
|
if (!vendor->name) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("Missing CPU vendor name"));
|
|
|
|
goto ignore;
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (ppc64VendorFind(map, vendor->name)) {
|
2012-10-15 09:07:50 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("CPU vendor %s already defined"), vendor->name);
|
|
|
|
goto ignore;
|
|
|
|
}
|
|
|
|
|
2012-12-18 23:06:45 +00:00
|
|
|
if (!map->vendors) {
|
2012-10-15 09:07:50 +00:00
|
|
|
map->vendors = vendor;
|
2012-12-18 23:06:45 +00:00
|
|
|
} else {
|
2012-10-15 09:07:50 +00:00
|
|
|
vendor->next = map->vendors;
|
|
|
|
map->vendors = vendor;
|
|
|
|
}
|
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
cleanup:
|
2012-12-18 23:06:45 +00:00
|
|
|
return 0;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
ignore:
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64VendorFree(vendor);
|
2012-12-18 23:06:45 +00:00
|
|
|
goto cleanup;
|
2012-10-15 09:07:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64ModelLoad(xmlXPathContextPtr ctxt,
|
|
|
|
struct ppc64_map *map)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_model *model;
|
2012-10-15 09:07:50 +00:00
|
|
|
char *vendor = NULL;
|
2012-12-19 00:35:51 +00:00
|
|
|
unsigned long pvr;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2013-07-04 10:03:29 +00:00
|
|
|
if (VIR_ALLOC(model) < 0)
|
2012-12-19 00:35:51 +00:00
|
|
|
return -1;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
|
|
|
model->name = virXPathString("string(@name)", ctxt);
|
2012-12-19 00:35:51 +00:00
|
|
|
if (!model->name) {
|
2012-10-15 09:07:50 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("Missing CPU model name"));
|
|
|
|
goto ignore;
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (ppc64ModelFind(map, model->name)) {
|
2012-12-19 00:35:51 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("CPU model %s already defined"), model->name);
|
|
|
|
goto ignore;
|
|
|
|
}
|
2012-10-15 09:07:50 +00:00
|
|
|
|
|
|
|
if (virXPathBoolean("boolean(./vendor)", ctxt)) {
|
|
|
|
vendor = virXPathString("string(./vendor/@name)", ctxt);
|
|
|
|
if (!vendor) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Invalid vendor element in CPU model %s"),
|
|
|
|
model->name);
|
|
|
|
goto ignore;
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (!(model->vendor = ppc64VendorFind(map, vendor))) {
|
2012-10-15 09:07:50 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Unknown vendor %s referenced by CPU model %s"),
|
|
|
|
vendor, model->name);
|
|
|
|
goto ignore;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-19 00:35:51 +00:00
|
|
|
if (!virXPathBoolean("boolean(./pvr)", ctxt) ||
|
|
|
|
virXPathULongHex("string(./pvr/@value)", ctxt, &pvr) < 0) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Missing or invalid PVR value in CPU model %s"),
|
|
|
|
model->name);
|
|
|
|
goto ignore;
|
|
|
|
}
|
|
|
|
model->data.pvr = pvr;
|
|
|
|
|
|
|
|
if (map->models == NULL) {
|
2012-10-15 09:07:50 +00:00
|
|
|
map->models = model;
|
2012-12-19 00:35:51 +00:00
|
|
|
} else {
|
2012-10-15 09:07:50 +00:00
|
|
|
model->next = map->models;
|
|
|
|
map->models = model;
|
|
|
|
}
|
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
cleanup:
|
2012-10-15 09:07:50 +00:00
|
|
|
VIR_FREE(vendor);
|
2012-12-19 00:35:51 +00:00
|
|
|
return 0;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
ignore:
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64ModelFree(model);
|
2012-12-19 00:35:51 +00:00
|
|
|
goto cleanup;
|
2012-10-15 09:07:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64MapLoadCallback(cpuMapElement element,
|
|
|
|
xmlXPathContextPtr ctxt,
|
|
|
|
void *data)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_map *map = data;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
|
|
|
switch (element) {
|
|
|
|
case CPU_MAP_ELEMENT_VENDOR:
|
2015-07-20 13:13:02 +00:00
|
|
|
return ppc64VendorLoad(ctxt, map);
|
2012-10-15 09:07:50 +00:00
|
|
|
case CPU_MAP_ELEMENT_MODEL:
|
2015-07-20 13:13:02 +00:00
|
|
|
return ppc64ModelLoad(ctxt, map);
|
2012-12-19 00:35:51 +00:00
|
|
|
case CPU_MAP_ELEMENT_FEATURE:
|
|
|
|
case CPU_MAP_ELEMENT_LAST:
|
2012-10-15 09:07:50 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64MapFree(struct ppc64_map *map)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
|
|
|
if (map == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
while (map->models != NULL) {
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_model *model = map->models;
|
2012-10-15 09:07:50 +00:00
|
|
|
map->models = model->next;
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64ModelFree(model);
|
2012-10-15 09:07:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
while (map->vendors != NULL) {
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_vendor *vendor = map->vendors;
|
2012-10-15 09:07:50 +00:00
|
|
|
map->vendors = vendor->next;
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64VendorFree(vendor);
|
2012-10-15 09:07:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VIR_FREE(map);
|
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
static struct ppc64_map *
|
|
|
|
ppc64LoadMap(void)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_map *map;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2013-07-04 10:03:29 +00:00
|
|
|
if (VIR_ALLOC(map) < 0)
|
2012-10-15 09:07:50 +00:00
|
|
|
return NULL;
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (cpuMapLoad("ppc64", ppc64MapLoadCallback, map) < 0)
|
2012-10-15 09:07:50 +00:00
|
|
|
goto error;
|
|
|
|
|
|
|
|
return map;
|
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
error:
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64MapFree(map);
|
2012-10-15 09:07:50 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-09-03 06:28:24 +00:00
|
|
|
static virCPUDataPtr
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64MakeCPUData(virArch arch, struct cpuPPC64Data *data)
|
2013-09-03 06:28:24 +00:00
|
|
|
{
|
|
|
|
virCPUDataPtr cpuData;
|
|
|
|
|
|
|
|
if (VIR_ALLOC(cpuData) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
cpuData->arch = arch;
|
2015-07-20 12:35:22 +00:00
|
|
|
cpuData->data.ppc64 = *data;
|
2013-09-03 06:28:24 +00:00
|
|
|
data = NULL;
|
|
|
|
|
|
|
|
return cpuData;
|
|
|
|
}
|
|
|
|
|
|
|
|
static virCPUCompareResult
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64Compute(virCPUDefPtr host,
|
|
|
|
const virCPUDef *cpu,
|
|
|
|
virCPUDataPtr *guestData,
|
|
|
|
char **message)
|
2013-09-03 06:28:24 +00:00
|
|
|
|
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_map *map = NULL;
|
|
|
|
struct ppc64_model *host_model = NULL;
|
|
|
|
struct ppc64_model *guest_model = NULL;
|
2013-09-03 06:28:24 +00:00
|
|
|
|
2013-09-09 05:56:33 +00:00
|
|
|
virCPUCompareResult ret = VIR_CPU_COMPARE_ERROR;
|
2013-09-03 06:28:24 +00:00
|
|
|
virArch arch;
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
if (cpu->arch != VIR_ARCH_NONE) {
|
|
|
|
bool found = false;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_CARDINALITY(archs); i++) {
|
|
|
|
if (archs[i] == cpu->arch) {
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
VIR_DEBUG("CPU arch %s does not match host arch",
|
|
|
|
virArchToString(cpu->arch));
|
|
|
|
if (message &&
|
|
|
|
virAsprintf(message,
|
|
|
|
_("CPU arch %s does not match host arch"),
|
|
|
|
virArchToString(cpu->arch)) < 0)
|
2013-09-09 05:56:33 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
ret = VIR_CPU_COMPARE_INCOMPATIBLE;
|
|
|
|
goto cleanup;
|
2013-09-03 06:28:24 +00:00
|
|
|
}
|
|
|
|
arch = cpu->arch;
|
|
|
|
} else {
|
|
|
|
arch = host->arch;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu->vendor &&
|
|
|
|
(!host->vendor || STRNEQ(cpu->vendor, host->vendor))) {
|
|
|
|
VIR_DEBUG("host CPU vendor does not match required CPU vendor %s",
|
|
|
|
cpu->vendor);
|
|
|
|
if (message &&
|
|
|
|
virAsprintf(message,
|
|
|
|
_("host CPU vendor does not match required "
|
|
|
|
"CPU vendor %s"),
|
|
|
|
cpu->vendor) < 0)
|
2013-09-09 05:56:33 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
ret = VIR_CPU_COMPARE_INCOMPATIBLE;
|
|
|
|
goto cleanup;
|
2013-09-03 06:28:24 +00:00
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (!(map = ppc64LoadMap()) ||
|
|
|
|
!(host_model = ppc64ModelFromCPU(host, map)) ||
|
|
|
|
!(guest_model = ppc64ModelFromCPU(cpu, map)))
|
2013-09-09 05:56:33 +00:00
|
|
|
goto cleanup;
|
2013-09-03 06:28:24 +00:00
|
|
|
|
|
|
|
if (guestData != NULL) {
|
|
|
|
if (cpu->type == VIR_CPU_TYPE_GUEST &&
|
|
|
|
cpu->match == VIR_CPU_MATCH_STRICT &&
|
|
|
|
STRNEQ(guest_model->name, host_model->name)) {
|
|
|
|
VIR_DEBUG("host CPU model does not match required CPU model %s",
|
|
|
|
guest_model->name);
|
|
|
|
if (message &&
|
|
|
|
virAsprintf(message,
|
|
|
|
_("host CPU model does not match required "
|
|
|
|
"CPU model %s"),
|
|
|
|
guest_model->name) < 0)
|
2013-09-09 05:56:33 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
ret = VIR_CPU_COMPARE_INCOMPATIBLE;
|
|
|
|
goto cleanup;
|
2013-09-03 06:28:24 +00:00
|
|
|
}
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (!(*guestData = ppc64MakeCPUData(arch, &guest_model->data)))
|
2013-09-09 05:56:33 +00:00
|
|
|
goto cleanup;
|
2013-09-03 06:28:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = VIR_CPU_COMPARE_IDENTICAL;
|
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
cleanup:
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64MapFree(map);
|
|
|
|
ppc64ModelFree(host_model);
|
|
|
|
ppc64ModelFree(guest_model);
|
2013-09-03 06:28:24 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-10-15 09:07:50 +00:00
|
|
|
static virCPUCompareResult
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64Compare(virCPUDefPtr host,
|
|
|
|
virCPUDefPtr cpu,
|
|
|
|
bool failIncompatible)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
2012-12-18 22:32:01 +00:00
|
|
|
if ((cpu->arch == VIR_ARCH_NONE || host->arch == cpu->arch) &&
|
|
|
|
STREQ(host->model, cpu->model))
|
|
|
|
return VIR_CPU_COMPARE_IDENTICAL;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2014-05-28 13:11:57 +00:00
|
|
|
if (failIncompatible) {
|
|
|
|
virReportError(VIR_ERR_CPU_INCOMPATIBLE, NULL);
|
|
|
|
return VIR_CPU_COMPARE_ERROR;
|
|
|
|
} else {
|
|
|
|
return VIR_CPU_COMPARE_INCOMPATIBLE;
|
|
|
|
}
|
2012-10-15 09:07:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64Decode(virCPUDefPtr cpu,
|
|
|
|
const virCPUData *data,
|
|
|
|
const char **models,
|
|
|
|
unsigned int nmodels,
|
|
|
|
const char *preferred ATTRIBUTE_UNUSED,
|
|
|
|
unsigned int flags)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_map *map;
|
|
|
|
const struct ppc64_model *model;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2013-08-02 19:08:19 +00:00
|
|
|
virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES, -1);
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (data == NULL || (map = ppc64LoadMap()) == NULL)
|
2012-10-15 09:07:50 +00:00
|
|
|
return -1;
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (!(model = ppc64ModelFindPVR(map, data->data.ppc64.pvr))) {
|
2012-12-19 00:35:51 +00:00
|
|
|
virReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("Cannot find CPU model with PVR 0x%08x"),
|
2015-07-20 12:35:22 +00:00
|
|
|
data->data.ppc64.pvr);
|
2012-12-19 00:53:25 +00:00
|
|
|
goto cleanup;
|
2012-12-19 00:35:51 +00:00
|
|
|
}
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2012-12-19 00:35:51 +00:00
|
|
|
if (!cpuModelIsAllowed(model->name, models, nmodels)) {
|
2012-12-19 00:53:25 +00:00
|
|
|
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
|
|
|
|
_("CPU model %s is not supported by hypervisor"),
|
2012-12-19 00:35:51 +00:00
|
|
|
model->name);
|
2012-12-19 00:53:25 +00:00
|
|
|
goto cleanup;
|
2012-10-15 09:07:50 +00:00
|
|
|
}
|
|
|
|
|
2013-05-03 12:41:23 +00:00
|
|
|
if (VIR_STRDUP(cpu->model, model->name) < 0 ||
|
|
|
|
(model->vendor && VIR_STRDUP(cpu->vendor, model->vendor->name) < 0)) {
|
2012-12-19 00:35:51 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2012-10-15 09:07:50 +00:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
cleanup:
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64MapFree(map);
|
2012-10-15 09:07:50 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64DataFree(virCPUDataPtr data)
|
2012-10-15 09:07:50 +00:00
|
|
|
{
|
|
|
|
if (data == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
VIR_FREE(data);
|
|
|
|
}
|
|
|
|
|
2012-12-18 18:44:23 +00:00
|
|
|
static virCPUDataPtr
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64NodeData(virArch arch)
|
2011-10-03 12:56:20 +00:00
|
|
|
{
|
2013-07-29 07:41:19 +00:00
|
|
|
virCPUDataPtr cpuData;
|
2011-10-03 12:56:20 +00:00
|
|
|
|
2013-07-29 07:41:19 +00:00
|
|
|
if (VIR_ALLOC(cpuData) < 0)
|
2011-10-03 12:56:20 +00:00
|
|
|
return NULL;
|
|
|
|
|
Ensure 'arch' is always set in cpuArchNodeData
The s390, ppc and arm CPU drivers never set the 'arch' field
in their impl of cpuArchNodeData. This leads to error messages
being reported from cpuDataFree later, due to trying to use
VIR_ARCH_NONE.
#0 virRaiseErrorFull (filename=filename@entry=0x76f94434 "cpu/cpu.c", funcname=funcname@entry=0x76f942dc <__FUNCTION__.18096> "cpuGetSubDriver", linenr=linenr@entry=58,
domain=domain@entry=31, code=code@entry=1, level=level@entry=VIR_ERR_ERROR, str1=0x76f70e18 "internal error: %s",
str2=str2@entry=0x7155f2ec "undefined hardware architecture", str3=str3@entry=0x0, int1=int1@entry=-1, int2=int2@entry=-1, fmt=0x76f70e18 "internal error: %s")
at util/virerror.c:646
#1 0x76e682ea in virReportErrorHelper (domcode=domcode@entry=31, errorcode=errorcode@entry=1, filename=0x76f94434 "cpu/cpu.c",
funcname=0x76f942dc <__FUNCTION__.18096> "cpuGetSubDriver", linenr=linenr@entry=58, fmt=0x76f7e7e4 "%s") at util/virerror.c:1292
#2 0x76ed82d4 in cpuGetSubDriver (arch=<optimized out>) at cpu/cpu.c:57
#3 cpuGetSubDriver (arch=VIR_ARCH_NONE) at cpu/cpu.c:51
#4 0x76ed8818 in cpuDataFree (data=data@entry=0x70c22d78) at cpu/cpu.c:216
#5 0x716aaec0 in virQEMUCapsInitCPU (arch=VIR_ARCH_ARMV7L, caps=0x70c29a08) at qemu/qemu_capabilities.c:867
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-09-04 16:41:55 +00:00
|
|
|
cpuData->arch = arch;
|
|
|
|
|
|
|
|
#if defined(__powerpc__) || defined(__powerpc64__)
|
2012-12-18 22:42:34 +00:00
|
|
|
asm("mfpvr %0"
|
2015-07-20 12:35:22 +00:00
|
|
|
: "=r" (cpuData->data.ppc64.pvr));
|
Ensure 'arch' is always set in cpuArchNodeData
The s390, ppc and arm CPU drivers never set the 'arch' field
in their impl of cpuArchNodeData. This leads to error messages
being reported from cpuDataFree later, due to trying to use
VIR_ARCH_NONE.
#0 virRaiseErrorFull (filename=filename@entry=0x76f94434 "cpu/cpu.c", funcname=funcname@entry=0x76f942dc <__FUNCTION__.18096> "cpuGetSubDriver", linenr=linenr@entry=58,
domain=domain@entry=31, code=code@entry=1, level=level@entry=VIR_ERR_ERROR, str1=0x76f70e18 "internal error: %s",
str2=str2@entry=0x7155f2ec "undefined hardware architecture", str3=str3@entry=0x0, int1=int1@entry=-1, int2=int2@entry=-1, fmt=0x76f70e18 "internal error: %s")
at util/virerror.c:646
#1 0x76e682ea in virReportErrorHelper (domcode=domcode@entry=31, errorcode=errorcode@entry=1, filename=0x76f94434 "cpu/cpu.c",
funcname=0x76f942dc <__FUNCTION__.18096> "cpuGetSubDriver", linenr=linenr@entry=58, fmt=0x76f7e7e4 "%s") at util/virerror.c:1292
#2 0x76ed82d4 in cpuGetSubDriver (arch=<optimized out>) at cpu/cpu.c:57
#3 cpuGetSubDriver (arch=VIR_ARCH_NONE) at cpu/cpu.c:51
#4 0x76ed8818 in cpuDataFree (data=data@entry=0x70c22d78) at cpu/cpu.c:216
#5 0x716aaec0 in virQEMUCapsInitCPU (arch=VIR_ARCH_ARMV7L, caps=0x70c29a08) at qemu/qemu_capabilities.c:867
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-09-04 16:41:55 +00:00
|
|
|
#endif
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2013-07-29 07:41:19 +00:00
|
|
|
return cpuData;
|
2011-10-03 12:56:20 +00:00
|
|
|
}
|
|
|
|
|
2013-09-03 06:28:24 +00:00
|
|
|
static virCPUCompareResult
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64GuestData(virCPUDefPtr host,
|
|
|
|
virCPUDefPtr guest,
|
|
|
|
virCPUDataPtr *data,
|
|
|
|
char **message)
|
2013-09-03 06:28:24 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
return ppc64Compute(host, guest, data, message);
|
2013-09-03 06:28:24 +00:00
|
|
|
}
|
|
|
|
|
2011-10-03 12:56:20 +00:00
|
|
|
static int
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64Update(virCPUDefPtr guest,
|
|
|
|
const virCPUDef *host)
|
2011-10-03 12:56:20 +00:00
|
|
|
{
|
2014-04-28 00:15:21 +00:00
|
|
|
switch ((virCPUMode) guest->mode) {
|
2013-09-03 06:28:24 +00:00
|
|
|
case VIR_CPU_MODE_HOST_MODEL:
|
|
|
|
case VIR_CPU_MODE_HOST_PASSTHROUGH:
|
|
|
|
guest->match = VIR_CPU_MATCH_EXACT;
|
|
|
|
virCPUDefFreeModel(guest);
|
|
|
|
return virCPUDefCopyModel(guest, host, true);
|
|
|
|
|
|
|
|
case VIR_CPU_MODE_CUSTOM:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case VIR_CPU_MODE_LAST:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Unexpected CPU mode: %d"), guest->mode);
|
|
|
|
return -1;
|
2011-10-03 12:56:20 +00:00
|
|
|
}
|
2012-12-20 11:38:25 +00:00
|
|
|
|
2012-10-15 09:07:50 +00:00
|
|
|
static virCPUDefPtr
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64Baseline(virCPUDefPtr *cpus,
|
|
|
|
unsigned int ncpus,
|
|
|
|
const char **models ATTRIBUTE_UNUSED,
|
|
|
|
unsigned int nmodels ATTRIBUTE_UNUSED,
|
|
|
|
unsigned int flags)
|
2011-10-03 12:56:20 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_map *map = NULL;
|
|
|
|
const struct ppc64_model *model;
|
|
|
|
const struct ppc64_vendor *vendor = NULL;
|
2012-10-15 09:07:50 +00:00
|
|
|
virCPUDefPtr cpu = NULL;
|
Convert 'int i' to 'size_t i' in src/cpu/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i;
|
2012-12-19 00:33:01 +00:00
|
|
|
|
2015-02-05 14:29:52 +00:00
|
|
|
virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES |
|
|
|
|
VIR_CONNECT_BASELINE_CPU_MIGRATABLE, NULL);
|
2013-08-02 19:08:19 +00:00
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (!(map = ppc64LoadMap()))
|
2012-12-19 00:33:01 +00:00
|
|
|
goto error;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (!(model = ppc64ModelFind(map, cpus[0]->model))) {
|
2012-12-19 00:33:01 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Unknown CPU model %s"), cpus[0]->model);
|
2012-10-15 09:07:50 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2012-12-19 00:33:01 +00:00
|
|
|
for (i = 0; i < ncpus; i++) {
|
2015-07-20 13:13:02 +00:00
|
|
|
const struct ppc64_vendor *vnd;
|
2012-12-11 12:58:54 +00:00
|
|
|
|
2012-12-19 00:33:01 +00:00
|
|
|
if (STRNEQ(cpus[i]->model, model->name)) {
|
|
|
|
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
|
|
|
|
_("CPUs are incompatible"));
|
|
|
|
goto error;
|
|
|
|
}
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2012-12-19 00:33:01 +00:00
|
|
|
if (!cpus[i]->vendor)
|
|
|
|
continue;
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (!(vnd = ppc64VendorFind(map, cpus[i]->vendor))) {
|
2012-12-19 00:33:01 +00:00
|
|
|
virReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("Unknown CPU vendor %s"), cpus[i]->vendor);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (model->vendor) {
|
|
|
|
if (model->vendor != vnd) {
|
|
|
|
virReportError(VIR_ERR_OPERATION_FAILED,
|
|
|
|
_("CPU vendor %s of model %s differs from "
|
|
|
|
"vendor %s"),
|
|
|
|
model->vendor->name, model->name,
|
|
|
|
vnd->name);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else if (vendor) {
|
|
|
|
if (vendor != vnd) {
|
|
|
|
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
|
|
|
|
_("CPU vendors do not match"));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
vendor = vnd;
|
|
|
|
}
|
2012-10-15 09:07:50 +00:00
|
|
|
}
|
|
|
|
|
2012-12-19 00:33:01 +00:00
|
|
|
if (VIR_ALLOC(cpu) < 0 ||
|
2013-05-03 12:41:23 +00:00
|
|
|
VIR_STRDUP(cpu->model, model->name) < 0)
|
2013-07-04 10:03:29 +00:00
|
|
|
goto error;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2013-05-03 12:41:23 +00:00
|
|
|
if (vendor && VIR_STRDUP(cpu->vendor, vendor->name) < 0)
|
|
|
|
goto error;
|
2012-12-19 00:33:01 +00:00
|
|
|
|
|
|
|
cpu->type = VIR_CPU_TYPE_GUEST;
|
|
|
|
cpu->match = VIR_CPU_MATCH_EXACT;
|
2012-10-15 09:07:50 +00:00
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
cleanup:
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64MapFree(map);
|
2011-10-03 12:56:20 +00:00
|
|
|
|
2012-10-15 09:07:50 +00:00
|
|
|
return cpu;
|
2012-12-19 00:33:01 +00:00
|
|
|
|
2014-03-25 06:50:40 +00:00
|
|
|
error:
|
2012-10-15 09:07:50 +00:00
|
|
|
virCPUDefFree(cpu);
|
|
|
|
cpu = NULL;
|
|
|
|
goto cleanup;
|
2011-10-03 12:56:20 +00:00
|
|
|
}
|
|
|
|
|
2014-11-20 10:08:21 +00:00
|
|
|
static int
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64GetModels(char ***models)
|
2014-11-20 10:08:21 +00:00
|
|
|
{
|
2015-07-20 13:13:02 +00:00
|
|
|
struct ppc64_map *map;
|
|
|
|
struct ppc64_model *model;
|
2014-11-20 10:08:21 +00:00
|
|
|
char *name;
|
|
|
|
size_t nmodels = 0;
|
|
|
|
|
2015-07-20 13:13:02 +00:00
|
|
|
if (!(map = ppc64LoadMap()))
|
2014-11-20 10:08:21 +00:00
|
|
|
goto error;
|
|
|
|
|
|
|
|
if (models && VIR_ALLOC_N(*models, 0) < 0)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
model = map->models;
|
|
|
|
while (model != NULL) {
|
2014-12-03 17:50:16 +00:00
|
|
|
if (models) {
|
|
|
|
if (VIR_STRDUP(name, model->name) < 0)
|
|
|
|
goto error;
|
2014-11-20 10:08:21 +00:00
|
|
|
|
2014-12-03 17:50:16 +00:00
|
|
|
if (VIR_APPEND_ELEMENT(*models, nmodels, name) < 0)
|
|
|
|
goto error;
|
|
|
|
} else {
|
|
|
|
nmodels++;
|
|
|
|
}
|
2014-11-20 10:08:21 +00:00
|
|
|
|
|
|
|
model = model->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
2015-07-20 13:13:02 +00:00
|
|
|
ppc64MapFree(map);
|
2014-11-20 10:08:21 +00:00
|
|
|
|
|
|
|
return nmodels;
|
|
|
|
|
|
|
|
error:
|
2014-12-03 17:50:16 +00:00
|
|
|
if (models) {
|
|
|
|
virStringFreeList(*models);
|
|
|
|
*models = NULL;
|
|
|
|
}
|
2014-11-20 10:08:21 +00:00
|
|
|
nmodels = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2015-07-20 12:35:22 +00:00
|
|
|
struct cpuArchDriver cpuDriverPPC64 = {
|
2011-10-03 12:56:20 +00:00
|
|
|
.name = "ppc64",
|
|
|
|
.arch = archs,
|
|
|
|
.narch = ARRAY_CARDINALITY(archs),
|
2015-07-20 13:13:02 +00:00
|
|
|
.compare = ppc64Compare,
|
|
|
|
.decode = ppc64Decode,
|
2011-10-03 12:56:20 +00:00
|
|
|
.encode = NULL,
|
2015-07-20 13:13:02 +00:00
|
|
|
.free = ppc64DataFree,
|
|
|
|
.nodeData = ppc64NodeData,
|
|
|
|
.guestData = ppc64GuestData,
|
|
|
|
.baseline = ppc64Baseline,
|
|
|
|
.update = ppc64Update,
|
2011-10-03 12:56:20 +00:00
|
|
|
.hasFeature = NULL,
|
2015-07-20 13:13:02 +00:00
|
|
|
.getModels = ppc64GetModels,
|
2011-10-03 12:56:20 +00:00
|
|
|
};
|