libvirt/libvirt-cpu-introduce-cpu-baseline-for-ARM-CPU.patch

From 2dc7c9bc3dc24d991834f7657cd65cf4b5774ff8 Mon Sep 17 00:00:00 2001
From: Xu Yandong <xuyandong2@huawei.com>
Date: Wed, 14 Aug 2019 21:33:37 +0800
Subject: [PATCH] cpu: introduce cpu baseline for ARM CPU

support vendor and model for ARM CPU

Signed-off-by: Xu Yandong <xuyandong2.huawei.com>
---
 src/cpu/cpu_arm.c | 610 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 610 insertions(+)

diff --git a/src/cpu/cpu_arm.c b/src/cpu/cpu_arm.c
index 65d69c0..0c8cd50 100644
--- a/src/cpu/cpu_arm.c
+++ b/src/cpu/cpu_arm.c
@@ -21,12 +21,23 @@
 
 #include <config.h>
 
+#include "virlog.h"
 #include "viralloc.h"
 #include "cpu.h"
 #include "virstring.h"
+#include "cpu_map.h"
+#include "cpu_arm.h"
+#include "virfile.h"
 
 #define VIR_FROM_THIS VIR_FROM_CPU
 
+VIR_LOG_INIT("cpu.cpu_arm");
+
+static const char *sysinfoCpuinfo = "/proc/cpuinfo";
+
+#define CPUINFO sysinfoCpuinfo
+#define CPUINFO_FILE_LEN (1024*1024)   /* 1MB limit for /proc/cpuinfo file */
+
 static const virArch archs[] = {
     VIR_ARCH_ARMV6L,
     VIR_ARCH_ARMV7B,
@@ -34,6 +45,605 @@ static const virArch archs[] = {
     VIR_ARCH_AARCH64,
 };
 
+typedef struct _virCPUarmVendor virCPUarmVendor;
+typedef virCPUarmVendor *virCPUarmVendorPtr;
+struct _virCPUarmVendor {
+    char *name;
+    unsigned long value;
+};
+
+typedef struct _virCPUarmModel virCPUarmModel;
+typedef virCPUarmModel *virCPUarmModelPtr;
+struct _virCPUarmModel {
+    char *name;
+    virCPUarmVendorPtr vendor;
+    virCPUarmData data;
+};
+
+typedef struct _virCPUarmMap virCPUarmMap;
+typedef virCPUarmMap *virCPUarmMapPtr;
+struct _virCPUarmMap {
+    size_t nvendors;
+    virCPUarmVendorPtr *vendors;
+    size_t nmodels;
+    virCPUarmModelPtr *models;
+};
+
+static virCPUarmMapPtr cpuMap;
+
+int virCPUarmDriverOnceInit(void);
+VIR_ONCE_GLOBAL_INIT(virCPUarmDriver);
+
+
+static void
+virCPUarmDataClear(virCPUarmData *data)
+{
+    if (!data)
+        return;
+
+    VIR_FREE(data->features);
+}
+
+
+static int
+armDataCopy(virCPUarmData *dst, const virCPUarmData *src)
+{
+    if (VIR_STRDUP(dst->features, src->features) < 0)
+        return -1;
+
+    dst->vendor_id = src->vendor_id;
+    dst->pvr = src->pvr;
+
+    return 0;
+}
+
+
+static void
+armDataIntersect(virCPUarmData *data1,
+                 const virCPUarmData *data2)
+{
+    char **features = NULL;
+    char **features1 = NULL;
+    char **features2 = NULL;
+    size_t count = 0;
+    size_t i;
+
+    if (!data1 || !data2)
+        return;
+
+    data1->pvr = MIN(data1->pvr, data2->pvr);
+
+    if (virStringIsEmpty(data1->features) ||
+        virStringIsEmpty(data2->features)) {
+        VIR_FREE(data1->features);
+        return;
+    }
+
+    if (STREQ_NULLABLE(data1->features, data2->features))
+        return;
+
+    if (!(features = virStringSplitCount(data1->features, " ", 0, &count)) ||
+        !(features1 = virStringSplitCount(data1->features, " ", 0, &count)) ||
+        !(features2 = virStringSplit(data2->features, " ", 0)))
+        goto cleanup;
+
+    for (i = 0; i < count; i++) {
+        if (!virStringListHasString((const char**)features2, features1[i]))
+            virStringListRemove(&features, features1[i]);
+    }
+
+    VIR_FREE(data1->features);
+    if (features)
+        data1->features = virStringListJoin((const char**)features, " ");
+
+ cleanup:
+    virStringListFree(features);
+    virStringListFree(features1);
+    virStringListFree(features2);
+    return;
+}
+
+
+static void
+virCPUarmDataFree(virCPUDataPtr cpuData)
+{
+    if (!cpuData)
+        return;
+
+    virCPUarmDataClear(&cpuData->data.arm);
+    VIR_FREE(cpuData);
+}
+
+
+static bool
+armFeaturesIsSub(char *subFeatures,
+                 char *fullFeatures)
+{
+    bool ret = false;
+    char **sub = NULL;
+    char **full = NULL;
+    size_t subCount = 0;
+    size_t fullCount = 0;
+    size_t i;
+
+    if (virStringIsEmpty(subFeatures))
+        return true;
+
+    if (virStringIsEmpty(fullFeatures))
+        return ret;
+
+    if (STREQ(subFeatures, fullFeatures))
+        return true;
+
+    if (!(sub = virStringSplitCount(subFeatures, " ", 0, &subCount)) ||
+        !(full = virStringSplitCount(fullFeatures, " ", 0, &fullCount)) ||
+        subCount > fullCount)
+        goto cleanup;
+
+    for (i = 0; i < subCount; i++) {
+        if (!virStringListHasString((const char**)full, sub[i]))
+            goto cleanup;
+    }
+
+    ret = true;
+
+ cleanup:
+    virStringListFree(sub);
+    virStringListFree(full);
+    return ret;
+}
+
+
+static void
+armVendorFree(virCPUarmVendorPtr vendor)
+{
+    if (!vendor)
+        return;
+
+    VIR_FREE(vendor->name);
+    VIR_FREE(vendor);
+}
+
+
+static virCPUarmVendorPtr
+armVendorFindByID(virCPUarmMapPtr map,
+                  unsigned long vendor_id)
+{
+    size_t i;
+
+    for (i = 0; i < map->nvendors; i++) {
+        if (map->vendors[i]->value == vendor_id)
+            return map->vendors[i];
+    }
+
+    return NULL;
+}
+
+
+static virCPUarmVendorPtr
+armVendorFindByName(virCPUarmMapPtr map,
+                    const char *name)
+{
+    size_t i;
+
+    for (i = 0; i < map->nvendors; i++) {
+        if (STREQ(map->vendors[i]->name, name))
+            return map->vendors[i];
+    }
+
+    return NULL;
+}
+
+
+static int
+armVendorParse(xmlXPathContextPtr ctxt,
+               const char *name,
+               void *data)
+{
+    virCPUarmMapPtr map = (virCPUarmMapPtr)data;
+    virCPUarmVendorPtr vendor = NULL;
+    int ret = -1;
+
+    if (VIR_ALLOC(vendor) < 0)
+        return ret;
+
+    if (VIR_STRDUP(vendor->name, name) < 0)
+        goto cleanup;
+
+    if (armVendorFindByName(map, vendor->name)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("CPU vendor %s already defined"), vendor->name);
+        goto cleanup;
+    }
+
+    if (virXPathULongHex("string(@value)", ctxt, &vendor->value) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("Missing CPU vendor value"));
+        goto cleanup;
+    }
+
+    if (armVendorFindByID(map, vendor->value)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("CPU vendor value 0x%2lx already defined"), vendor->value);
+        goto cleanup;
+    }
+
+    if (VIR_APPEND_ELEMENT(map->vendors, map->nvendors, vendor) < 0)
+        goto cleanup;
+
+    ret = 0;
+
+ cleanup:
+    armVendorFree(vendor);
+    return ret;
+
+}
+
+
+static void
+armModelFree(virCPUarmModelPtr model)
+{
+    if (!model)
+        return;
+
+    virCPUarmDataClear(&model->data);
+    VIR_FREE(model->name);
+    VIR_FREE(model);
+}
+
+
+static virCPUarmModelPtr
+armModelCopy(virCPUarmModelPtr model)
+{
+    virCPUarmModelPtr copy;
+
+    if (VIR_ALLOC(copy) < 0)
+        goto cleanup;
+
+    if (VIR_STRDUP(copy->name, model->name) < 0)
+        goto cleanup;
+
+    if (armDataCopy(&copy->data, &model->data) < 0)
+        goto cleanup;
+
+    copy->vendor = model->vendor;
+
+    return copy;
+
+ cleanup:
+    armModelFree(copy);
+    return NULL;
+}
+
+
+static virCPUarmModelPtr
+armModelFind(virCPUarmMapPtr map,
+             const char *name)
+{
+    size_t i;
+
+    for (i = 0; i < map->nmodels; i++) {
+        if (STREQ(map->models[i]->name, name))
+            return map->models[i];
+    }
+
+    return NULL;
+}
+
+
+static virCPUarmModelPtr
+armModelFindByPVR(virCPUarmMapPtr map,
+                  unsigned long pvr)
+{
+    size_t i;
+
+    for (i = 0; i < map->nmodels; i++) {
+        if (map->models[i]->data.pvr == pvr)
+            return map->models[i];
+    }
+
+    return NULL;
+}
+
+
+static virCPUarmModelPtr
+armModelFromCPU(const virCPUDef *cpu,
+               virCPUarmMapPtr map)
+{
+    virCPUarmModelPtr model = NULL;
+    virCPUarmVendorPtr vendor = NULL;
+    char **features = NULL;
+    size_t i;
+
+    if (!cpu->model) {
+        virReportError(VIR_ERR_INVALID_ARG, "%s",
+                       _("no CPU model specified"));
+        return NULL;
+    }
+
+    if (!(model = armModelFind(map, cpu->model))) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Unknown CPU model %s"), cpu->model);
+        return NULL;
+    }
+
+    if (!(model = armModelCopy(model)))
+        goto cleanup;
+
+    if (cpu->vendor) {
+        if (!(vendor = armVendorFindByName(map, cpu->vendor))) {
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unknown CPU vendor %s"), cpu->vendor);
+            goto error;
+        }
+        model->data.vendor_id = vendor->value;
+    }
+
+    if (cpu->nfeatures) {
+        if (VIR_REALLOC_N(features, cpu->nfeatures + 1) < 0)
+            goto cleanup;
+
+        features[cpu->nfeatures] = NULL;
+        for (i = 0; i < cpu->nfeatures; i++) {
+            if (VIR_STRDUP(features[i], cpu->features[i].name) < 0)
+                goto error;
+        }
+
+        VIR_FREE(model->data.features);
+        model->data.features = virStringListJoin((const char **)features, " ");
+    }
+
+ cleanup:
+    virStringListFree(features);
+    return model;
+
+ error:
+    armModelFree(model);
+    model = NULL;
+    goto cleanup;
+}
+
+static int
+armModelParse(xmlXPathContextPtr ctxt,
+              const char *name,
+              void *data)
+{
+    virCPUarmMapPtr map = (virCPUarmMapPtr)data;
+    virCPUarmModel *model;
+    xmlNodePtr *nodes = NULL;
+    char *vendor = NULL;
+    int ret = -1;
+
+    if (VIR_ALLOC(model) < 0)
+        goto error;
+
+    if (VIR_STRDUP(model->name, name) < 0)
+        goto error;
+
+    if (armModelFind(map, model->name)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("CPU model %s already defined"), model->name);
+        goto error;
+    }
+
+    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 error;
+        }
+
+        if (!(model->vendor = armVendorFindByName(map, vendor))) {
+            virReportError(VIR_ERR_INTERNAL_ERROR,
+                           _("Unknown vendor %s referenced by CPU model %s"),
+                           vendor, model->name);
+            goto error;
+        }
+    }
+
+    if (!virXPathBoolean("boolean(./pvr)", ctxt)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Missing PVR information for CPU model %s"),
+                       model->name);
+        goto error;
+    }
+
+    if (virXPathULongHex("string(./pvr/@value)", ctxt, &model->data.pvr) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Missing or invalid PVR value in CPU model %s"),
+                       model->name);
+        goto error;
+    }
+
+    if (VIR_APPEND_ELEMENT(map->models, map->nmodels, model) < 0)
+        goto error;
+
+    ret = 0;
+
+ cleanup:
+    VIR_FREE(vendor);
+    VIR_FREE(nodes);
+    return ret;
+
+ error:
+    armModelFree(model);
+    goto cleanup;
+}
+
+
+static void
+armMapFree(virCPUarmMapPtr map)
+{
+    size_t i;
+
+    if (!map)
+        return;
+
+    for (i = 0; i < map->nmodels; i++)
+        armModelFree(map->models[i]);
+    VIR_FREE(map->models);
+
+    for (i = 0; i < map->nvendors; i++)
+        armVendorFree(map->vendors[i]);
+    VIR_FREE(map->vendors);
+
+    VIR_FREE(map);
+}
+
+
+static virCPUarmMapPtr
+virCPUarmLoadMap(void)
+{
+    virCPUarmMapPtr map;
+
+    if (VIR_ALLOC(map) < 0)
+        goto error;
+
+    if (cpuMapLoad("arm", armVendorParse, NULL, armModelParse, map) < 0)
+        goto error;
+
+    return map;
+
+ error:
+    armMapFree(map);
+    return NULL;
+}
+
+int
+virCPUarmDriverOnceInit(void)
+{
+    if (!(cpuMap = virCPUarmLoadMap()))
+        return -1;
+
+    return 0;
+}
+
+
+static virCPUarmMapPtr
+virCPUarmGetMap(void)
+{
+    if (virCPUarmDriverInitialize() < 0)
+        return NULL;
+
+    return cpuMap;
+}
+
+static virCPUDataPtr
+armMakeCPUData(virArch arch,
+               virCPUarmData *data)
+{
+    virCPUDataPtr cpuData;
+
+    if (VIR_ALLOC(cpuData) < 0)
+        return NULL;
+
+    cpuData->arch = arch;
+
+    if (armDataCopy(&cpuData->data.arm, data) < 0)
+        VIR_FREE(cpuData);
+
+    return cpuData;
+}
+
+
+static int
+armCpuDataParseFeatures(virCPUDefPtr cpu,
+                        const virCPUarmData *cpuData)
+{
+    int ret = -1;
+    size_t i;
+    char **features;
+
+    if (!cpu || !cpuData)
+        return ret;
+
+    if (!(features = virStringSplitCount(cpuData->features, " ",
+                                         0, &cpu->nfeatures)))
+        return ret;
+    if (cpu->nfeatures) {
+        if (VIR_ALLOC_N(cpu->features, cpu->nfeatures) < 0)
+            goto error;
+
+        for (i = 0; i < cpu->nfeatures; i++) {
+            cpu->features[i].policy = VIR_CPU_FEATURE_REQUIRE;
+            if (VIR_STRDUP(cpu->features[i].name, features[i]) < 0)
+                goto error;
+        }
+    }
+
+    ret = 0;
+
+ cleanup:
+    virStringListFree(features);
+    return ret;
+
+ error:
+    for (i = 0; i < cpu->nfeatures; i++)
+        VIR_FREE(cpu->features[i].name);
+    VIR_FREE(cpu->features);
+    cpu->nfeatures = 0;
+    goto cleanup;
+}
+
+
+static int
+armDecode(virCPUDefPtr cpu,
+          const virCPUarmData *cpuData,
+          virDomainCapsCPUModelsPtr models)
+{
+    virCPUarmMapPtr map;
+    virCPUarmModelPtr model;
+    virCPUarmVendorPtr vendor = NULL;
+
+    if (!cpuData || !(map = virCPUarmGetMap()))
+        return -1;
+
+    if (!(model = armModelFindByPVR(map, cpuData->pvr))) {
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("Cannot find CPU model with PVR 0x%03lx"),
+                       cpuData->pvr);
+        return -1;
+    }
+
+    if (!virCPUModelIsAllowed(model->name, models)) {
+        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+                       _("CPU model %s is not supported by hypervisor"),
+                       model->name);
+        return -1;
+    }
+
+    if (VIR_STRDUP(cpu->model, model->name) < 0)
+        return -1;
+
+    if (cpuData->vendor_id &&
+        !(vendor = armVendorFindByID(map, cpuData->vendor_id))) {
+        virReportError(VIR_ERR_OPERATION_FAILED,
+                       _("Cannot find CPU vendor with vendor id 0x%02lx"),
+                       cpuData->vendor_id);
+        return -1;
+    }
+
+    if (vendor && VIR_STRDUP(cpu->vendor, vendor->name) < 0)
+        return -1;
+
+    if (cpuData->features &&
+        armCpuDataParseFeatures(cpu, cpuData) < 0)
+        return -1;
+
+    return 0;
+}
+
+
+static int
+armDecodeCPUData(virCPUDefPtr cpu,
+                 const virCPUData *data,
+                 virDomainCapsCPUModelsPtr models)
+{
+    return armDecode(cpu, &data->data.arm, models);
+}
+
 
 static int
 virCPUarmUpdate(virCPUDefPtr guest,
-- 
2.19.1