cputest.c 41.4 KB
Newer Older
1 2 3
/*
 * cputest.c: Test the libvirtd internal CPU APIs
 *
4
 * Copyright (C) 2010-2014 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16
 *
 * 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
17
 * License along with this library.  If not, see
O
Osier Yang 已提交
18
 * <http://www.gnu.org/licenses/>.
19 20 21 22 23 24 25 26 27 28
 */

#include <config.h>

#include <unistd.h>

#include <sys/types.h>
#include <fcntl.h>

#include "internal.h"
29
#include "virxml.h"
30
#include "viralloc.h"
31
#include "virbuffer.h"
32 33 34
#include "testutils.h"
#include "cpu_conf.h"
#include "cpu/cpu.h"
J
Jiri Denemark 已提交
35
#include "cpu/cpu_x86.h"
36
#include "cpu/cpu_map.h"
37
#include "virstring.h"
38

39
#if WITH_QEMU && WITH_YAJL
J
Jiri Denemark 已提交
40 41
# include "testutilsqemu.h"
# include "qemumonitortestutils.h"
42
# define LIBVIRT_QEMU_CAPSPRIV_H_ALLOW
43
# include "qemu/qemu_capspriv.h"
J
Jiri Denemark 已提交
44 45
#endif

46 47 48 49 50 51 52 53 54 55
#define VIR_FROM_THIS VIR_FROM_CPU

enum cpuTestBoolWithError {
    FAIL    = -1,
    NO      = 0,
    YES     = 1
};


struct data {
56
    virArch arch;
57 58
    const char *host;
    const char *name;
59
    virDomainCapsCPUModelsPtr models;
60
    const char *modelsName;
61
    unsigned int flags;
62 63 64
    int result;
};

65
#if WITH_QEMU && WITH_YAJL
J
Jiri Denemark 已提交
66 67 68
static virQEMUDriver driver;
#endif

69 70

static virCPUDefPtr
71
cpuTestLoadXML(virArch arch, const char *name)
72
{
73
    char *xml = NULL;
74 75 76 77
    xmlDocPtr doc = NULL;
    xmlXPathContextPtr ctxt = NULL;
    virCPUDefPtr cpu = NULL;

78 79
    xml = g_strdup_printf("%s/cputestdata/%s-%s.xml", abs_srcdir,
                          virArchToString(arch), name);
80

81
    if (!(doc = virXMLParseFileCtxt(xml, &ctxt)))
82 83
        goto cleanup;

J
Jiri Denemark 已提交
84
    virCPUDefParseXML(ctxt, NULL, VIR_CPU_TYPE_AUTO, &cpu);
85

86
 cleanup:
87 88
    xmlXPathFreeContext(ctxt);
    xmlFreeDoc(doc);
89
    VIR_FREE(xml);
90 91 92 93 94
    return cpu;
}


static virCPUDefPtr *
95
cpuTestLoadMultiXML(virArch arch,
96 97 98
                    const char *name,
                    unsigned int *count)
{
99
    char *xml = NULL;
100 101 102 103 104
    xmlDocPtr doc = NULL;
    xmlXPathContextPtr ctxt = NULL;
    xmlNodePtr *nodes = NULL;
    virCPUDefPtr *cpus = NULL;
    int n;
105
    size_t i;
106

107 108
    xml = g_strdup_printf("%s/cputestdata/%s-%s.xml", abs_srcdir,
                          virArchToString(arch), name);
109

110
    if (!(doc = virXMLParseFileCtxt(xml, &ctxt)))
J
Jiri Denemark 已提交
111
        goto cleanup;
112 113

    n = virXPathNodeSet("/cpuTest/cpu", ctxt, &nodes);
114 115
    if (n <= 0 || (VIR_ALLOC_N(cpus, n) < 0)) {
        fprintf(stderr, "\nNo /cpuTest/cpu elements found in %s\n", xml);
J
Jiri Denemark 已提交
116
        goto cleanup;
117
    }
118 119 120

    for (i = 0; i < n; i++) {
        ctxt->node = nodes[i];
J
Jiri Denemark 已提交
121
        if (virCPUDefParseXML(ctxt, NULL, VIR_CPU_TYPE_HOST, &cpus[i]) < 0)
J
Jiri Denemark 已提交
122
            goto cleanup_cpus;
123 124 125 126
    }

    *count = n;

127
 cleanup:
128 129
    VIR_FREE(xml);
    VIR_FREE(nodes);
130 131 132 133
    xmlXPathFreeContext(ctxt);
    xmlFreeDoc(doc);
    return cpus;

134
 cleanup_cpus:
J
Jiri Denemark 已提交
135 136 137
    for (i = 0; i < n; i++)
        virCPUDefFree(cpus[i]);
    VIR_FREE(cpus);
138 139 140 141 142
    goto cleanup;
}


static int
143
cpuTestCompareXML(virArch arch,
E
Eric Blake 已提交
144
                  virCPUDef *cpu,
145
                  const char *name)
146
{
147
    char *xml = NULL;
148 149 150
    char *actual = NULL;
    int ret = -1;

151 152
    xml = g_strdup_printf("%s/cputestdata/%s-%s.xml", abs_srcdir,
                          virArchToString(arch), name);
153

154
    if (!(actual = virCPUDefFormat(cpu, NULL)))
155 156
        goto cleanup;

157
    if (virTestCompareToFile(actual, xml) < 0)
158 159 160 161
        goto cleanup;

    ret = 0;

162
 cleanup:
163 164
    VIR_FREE(xml);
    VIR_FREE(actual);
165 166 167 168 169 170 171 172 173 174 175 176
    return ret;
}


static const char *
cpuTestCompResStr(virCPUCompareResult result)
{
    switch (result) {
    case VIR_CPU_COMPARE_ERROR:         return "ERROR";
    case VIR_CPU_COMPARE_INCOMPATIBLE:  return "INCOMPATIBLE";
    case VIR_CPU_COMPARE_IDENTICAL:     return "IDENTICAL";
    case VIR_CPU_COMPARE_SUPERSET:      return "SUPERSET";
177
    case VIR_CPU_COMPARE_LAST:          break;
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
    }

    return "unknown";
}


static const char *
cpuTestBoolWithErrorStr(enum cpuTestBoolWithError result)
{
    switch (result) {
    case FAIL:  return "FAIL";
    case NO:    return "NO";
    case YES:   return "YES";
    }

    return "unknown";
}


static int
cpuTestCompare(const void *arg)
{
    const struct data *data = arg;
    int ret = -1;
    virCPUDefPtr host = NULL;
    virCPUDefPtr cpu = NULL;
    virCPUCompareResult result;

    if (!(host = cpuTestLoadXML(data->arch, data->host)) ||
        !(cpu = cpuTestLoadXML(data->arch, data->name)))
        goto cleanup;

J
Jiri Denemark 已提交
210
    result = virCPUCompare(host->arch, host, cpu, false);
211 212 213 214
    if (data->result == VIR_CPU_COMPARE_ERROR)
        virResetLastError();

    if (data->result != result) {
215
        VIR_TEST_VERBOSE("\nExpected result %s, got %s",
216 217
                    cpuTestCompResStr(data->result),
                    cpuTestCompResStr(result));
218 219
        /* Pad to line up with test name ... in virTestRun */
        VIR_TEST_VERBOSE("%74s", "... ");
220 221 222 223 224
        goto cleanup;
    }

    ret = 0;

225
 cleanup:
226 227 228 229 230 231 232
    virCPUDefFree(host);
    virCPUDefFree(cpu);
    return ret;
}


static int
J
Jiri Denemark 已提交
233
cpuTestGuestCPU(const void *arg)
234 235
{
    const struct data *data = arg;
236
    int ret = -2;
237 238 239 240 241 242 243 244 245 246
    virCPUDefPtr host = NULL;
    virCPUDefPtr cpu = NULL;
    virCPUCompareResult cmpResult;
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    char *result = NULL;

    if (!(host = cpuTestLoadXML(data->arch, data->host)) ||
        !(cpu = cpuTestLoadXML(data->arch, data->name)))
        goto cleanup;

247 248 249
    if (virCPUConvertLegacy(host->arch, cpu) < 0)
        goto cleanup;

J
Jiri Denemark 已提交
250
    cmpResult = virCPUCompare(host->arch, host, cpu, false);
251
    if (cmpResult == VIR_CPU_COMPARE_ERROR ||
252 253
        cmpResult == VIR_CPU_COMPARE_INCOMPATIBLE) {
        ret = -1;
254
        goto cleanup;
255
    }
256

J
Jiri Denemark 已提交
257
    if (virCPUUpdate(host->arch, cpu, host) < 0 ||
258
        virCPUTranslate(host->arch, cpu, data->models) < 0) {
259
        ret = -1;
260 261 262
        goto cleanup;
    }

263
    virBufferAsprintf(&buf, "%s+%s", data->host, data->name);
264
    if (data->modelsName)
265
        virBufferAsprintf(&buf, ",%s", data->modelsName);
266 267 268 269
    virBufferAddLit(&buf, "-result");

    result = virBufferContentAndReset(&buf);

270
    if (cpuTestCompareXML(data->arch, cpu, result) < 0)
271 272 273
        goto cleanup;

    ret = 0;
274

275
 cleanup:
276 277 278
    VIR_FREE(result);
    virCPUDefFree(host);
    virCPUDefFree(cpu);
279 280 281 282 283 284 285

    if (ret == data->result) {
        /* We got the result we expected, whether it was
         * a success or a failure */
        virResetLastError();
        ret = 0;
    } else {
286
        VIR_TEST_VERBOSE("\nExpected result %d, got %d",
287 288 289 290 291 292
                         data->result, ret);
        /* Pad to line up with test name ... in virTestRun */
        VIR_TEST_VERBOSE("%74s", "... ");
        ret = -1;
    }

293 294 295 296 297 298 299 300 301 302 303 304
    return ret;
}


static int
cpuTestBaseline(const void *arg)
{
    const struct data *data = arg;
    int ret = -1;
    virCPUDefPtr *cpus = NULL;
    virCPUDefPtr baseline = NULL;
    unsigned int ncpus = 0;
305
    char *result = NULL;
306
    const char *suffix;
307
    size_t i;
308 309 310 311

    if (!(cpus = cpuTestLoadMultiXML(data->arch, data->name, &ncpus)))
        goto cleanup;

312
    baseline = virCPUBaseline(data->arch, cpus, ncpus, NULL, NULL,
313
                              !!(data->flags & VIR_CONNECT_BASELINE_CPU_MIGRATABLE));
314 315 316 317 318 319 320 321

    if (baseline &&
        (data->flags & VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES) &&
        virCPUExpandFeatures(data->arch, baseline) < 0) {
        virCPUDefFree(baseline);
        baseline = NULL;
    }

322 323
    if (data->result < 0) {
        virResetLastError();
324
        if (!baseline) {
325
            ret = 0;
326 327
        } else {
            VIR_TEST_VERBOSE("\n%-70s... ",
328
                    "virCPUBaseline was expected to fail but it succeeded");
329 330 331 332 333 334
        }
        goto cleanup;
    }
    if (!baseline)
        goto cleanup;

335 336
    if (data->flags & VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES)
        suffix = "expanded";
337 338
    else if (data->flags & VIR_CONNECT_BASELINE_CPU_MIGRATABLE)
        suffix = "migratable";
339 340
    else
        suffix = "result";
341
    result = g_strdup_printf("%s-%s", data->name, suffix);
342

343
    if (cpuTestCompareXML(data->arch, baseline, result) < 0)
344 345 346 347 348
        goto cleanup;

    for (i = 0; i < ncpus; i++) {
        virCPUCompareResult cmp;

J
Jiri Denemark 已提交
349
        cmp = virCPUCompare(cpus[i]->arch, cpus[i], baseline, false);
350 351
        if (cmp != VIR_CPU_COMPARE_SUPERSET &&
            cmp != VIR_CPU_COMPARE_IDENTICAL) {
352
            VIR_TEST_VERBOSE("\nbaseline CPU is incompatible with CPU %zu",
353 354
                             i);
            VIR_TEST_VERBOSE("%74s", "... ");
355 356 357 358 359 360 361
            ret = -1;
            goto cleanup;
        }
    }

    ret = 0;

362
 cleanup:
363 364 365
    if (cpus) {
        for (i = 0; i < ncpus; i++)
            virCPUDefFree(cpus[i]);
366
        VIR_FREE(cpus);
367 368
    }
    virCPUDefFree(baseline);
369
    VIR_FREE(result);
370 371 372 373 374 375 376 377 378 379
    return ret;
}


static int
cpuTestUpdate(const void *arg)
{
    const struct data *data = arg;
    int ret = -1;
    virCPUDefPtr host = NULL;
380
    virCPUDefPtr migHost = NULL;
381
    virCPUDefPtr cpu = NULL;
382
    char *result = NULL;
383 384 385 386 387

    if (!(host = cpuTestLoadXML(data->arch, data->host)) ||
        !(cpu = cpuTestLoadXML(data->arch, data->name)))
        goto cleanup;

388 389 390 391
    if (!(migHost = virCPUCopyMigratable(data->arch, host)))
        goto cleanup;

    if (virCPUUpdate(host->arch, cpu, migHost) < 0)
392 393
        goto cleanup;

394
    result = g_strdup_printf("%s+%s", data->host, data->name);
395

396
    ret = cpuTestCompareXML(data->arch, cpu, result);
397

398
 cleanup:
399 400
    virCPUDefFree(host);
    virCPUDefFree(cpu);
401
    virCPUDefFree(migHost);
402
    VIR_FREE(result);
403 404 405 406 407 408 409 410 411 412
    return ret;
}


static int
cpuTestHasFeature(const void *arg)
{
    const struct data *data = arg;
    int ret = -1;
    virCPUDefPtr host = NULL;
413
    virCPUDataPtr hostData = NULL;
414 415 416 417 418 419 420 421 422
    int result;

    if (!(host = cpuTestLoadXML(data->arch, data->host)))
        goto cleanup;

    if (cpuEncode(host->arch, host, NULL, &hostData,
                  NULL, NULL, NULL, NULL) < 0)
        goto cleanup;

423 424 425 426 427
    result = virCPUCheckFeature(host->arch, host, data->name);

    if (data->result == result)
        result = virCPUDataCheckFeature(hostData, data->name);

428 429 430 431
    if (data->result == -1)
        virResetLastError();

    if (data->result != result) {
432
        VIR_TEST_VERBOSE("\nExpected result %s, got %s",
433 434 435 436
            cpuTestBoolWithErrorStr(data->result),
            cpuTestBoolWithErrorStr(result));
        /* Pad to line up with test name ... in virTestRun */
        VIR_TEST_VERBOSE("%74s", "... ");
437 438 439 440 441
        goto cleanup;
    }

    ret = 0;

442
 cleanup:
J
Jiri Denemark 已提交
443
    virCPUDataFree(hostData);
444 445 446 447 448
    virCPUDefFree(host);
    return ret;
}


449
typedef enum {
450
    /* No JSON data from QEMU. */
451
    JSON_NONE,
452
    /* Only a reply from query-cpu-model-expansion QMP command. */
453
    JSON_HOST,
454 455 456
    /* Replies from both query-cpu-model-expansion and query-cpu-definitions
     * QMP commands.
     */
457
    JSON_MODELS,
458 459 460 461 462 463 464 465
    /* Same as JSON_MODELS, but the reply from query-cpu-definitions has to
     * be parsed for providing the correct result. This happens when the
     * CPU model detected by libvirt has non-empty unavailable-features array
     * in query-cpu-definitions reply or when the CPU model detected from CPUID
     * differs from the one we get from QEMU and we need to translate them for
     * comparison. Such tests require QEMU driver to be enabled.
     */
    JSON_MODELS_REQUIRED,
466 467
} cpuTestCPUIDJson;

468
#if WITH_QEMU && WITH_YAJL
469 470 471 472 473 474
static virQEMUCapsPtr
cpuTestMakeQEMUCaps(const struct data *data)
{
    virQEMUCapsPtr qemuCaps = NULL;
    qemuMonitorTestPtr testMon = NULL;
    qemuMonitorCPUModelInfoPtr model = NULL;
475
    virCPUDefPtr cpu = NULL;
476
    bool fail_no_props = true;
477 478
    char *json = NULL;

479 480
    json = g_strdup_printf("%s/cputestdata/%s-cpuid-%s.json", abs_srcdir,
                           virArchToString(data->arch), data->host);
481 482 483 484

    if (!(testMon = qemuMonitorTestNewFromFile(json, driver.xmlopt, true)))
        goto error;

485
    cpu = virCPUDefNew();
486

487 488
    cpu->model = g_strdup("host");

489 490 491
    if (ARCH_IS_S390(data->arch))
        fail_no_props = false;

492 493
    if (qemuMonitorGetCPUModelExpansion(qemuMonitorTestGetMonitor(testMon),
                                        QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC,
494
                                        cpu, true, fail_no_props, &model) < 0)
495 496 497 498 499 500
        goto error;

    if (!(qemuCaps = virQEMUCapsNew()))
        goto error;

    virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM);
501 502
    if (data->flags == JSON_MODELS ||
        data->flags == JSON_MODELS_REQUIRED)
503 504 505 506 507 508
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_QUERY_CPU_DEFINITIONS);

    virQEMUCapsSetArch(qemuCaps, data->arch);
    virQEMUCapsSetCPUModelInfo(qemuCaps, VIR_DOMAIN_VIRT_KVM, model);
    model = NULL;

509 510
    if (virQEMUCapsProbeCPUDefinitionsTest(qemuCaps,
                                           qemuMonitorTestGetMonitor(testMon)) < 0)
511 512 513 514 515
        goto error;

 cleanup:
    qemuMonitorCPUModelInfoFree(model);
    qemuMonitorTestFree(testMon);
516
    virCPUDefFree(cpu);
517 518 519 520 521 522 523 524 525
    VIR_FREE(json);

    return qemuCaps;

 error:
    virObjectUnref(qemuCaps);
    qemuCaps = NULL;
    goto cleanup;
}
526 527


528 529 530
static int
cpuTestGetCPUModels(const struct data *data,
                    virDomainCapsCPUModelsPtr *models)
531 532 533
{
    virQEMUCapsPtr qemuCaps;

534 535 536 537 538
    *models = NULL;

    if (data->flags != JSON_MODELS &&
        data->flags != JSON_MODELS_REQUIRED)
        return 0;
539 540

    if (!(qemuCaps = cpuTestMakeQEMUCaps(data)))
541
        return -1;
542

543
    *models = virQEMUCapsGetCPUModels(qemuCaps, VIR_DOMAIN_VIRT_KVM, NULL, NULL);
544 545 546

    virObjectUnref(qemuCaps);

547
    return 0;
548 549
}

550
#else /* if WITH_QEMU && WITH_YAJL */
551

552 553 554
static int
cpuTestGetCPUModels(const struct data *data,
                    virDomainCapsCPUModelsPtr *models)
555
{
556 557 558 559 560 561
    *models = NULL;

    if (data->flags == JSON_MODELS_REQUIRED)
        return EXIT_AM_SKIP;

    return 0;
562 563
}

564 565 566
#endif


J
Jiri Denemark 已提交
567
static int
568
cpuTestCPUID(bool guest, const void *arg)
J
Jiri Denemark 已提交
569 570 571 572 573 574 575 576
{
    const struct data *data = arg;
    int ret = -1;
    virCPUDataPtr hostData = NULL;
    char *hostFile = NULL;
    char *host = NULL;
    virCPUDefPtr cpu = NULL;
    char *result = NULL;
577
    virDomainCapsCPUModelsPtr models = NULL;
J
Jiri Denemark 已提交
578

579 580
    hostFile = g_strdup_printf("%s/cputestdata/%s-cpuid-%s.xml", abs_srcdir,
                               virArchToString(data->arch), data->host);
J
Jiri Denemark 已提交
581 582

    if (virTestLoadFile(hostFile, &host) < 0 ||
J
Jiri Denemark 已提交
583
        !(hostData = virCPUDataParse(host)))
J
Jiri Denemark 已提交
584 585
        goto cleanup;

586
    cpu = virCPUDefNew();
J
Jiri Denemark 已提交
587
    cpu->arch = hostData->arch;
588
    if (guest) {
J
Jiri Denemark 已提交
589 590 591 592 593 594 595
        cpu->type = VIR_CPU_TYPE_GUEST;
        cpu->match = VIR_CPU_MATCH_EXACT;
        cpu->fallback = VIR_CPU_FALLBACK_FORBID;
    } else {
        cpu->type = VIR_CPU_TYPE_HOST;
    }

596 597 598 599 600 601 602 603 604
    if (guest) {
        int rc;

        rc = cpuTestGetCPUModels(data, &models);
        if (rc != 0) {
            ret = rc;
            goto cleanup;
        }
    }
605 606

    if (cpuDecode(cpu, hostData, models) < 0)
J
Jiri Denemark 已提交
607 608
        goto cleanup;

609
    result = g_strdup_printf("cpuid-%s-%s", data->host, guest ? "guest" : "host");
J
Jiri Denemark 已提交
610

611
    ret = cpuTestCompareXML(data->arch, cpu, result);
J
Jiri Denemark 已提交
612 613 614 615

 cleanup:
    VIR_FREE(hostFile);
    VIR_FREE(host);
J
Jiri Denemark 已提交
616
    virCPUDataFree(hostData);
J
Jiri Denemark 已提交
617 618
    virCPUDefFree(cpu);
    VIR_FREE(result);
619
    virObjectUnref(models);
J
Jiri Denemark 已提交
620 621 622 623
    return ret;
}


624 625 626 627 628 629 630 631 632 633 634 635 636 637
static int
cpuTestHostCPUID(const void *arg)
{
    return cpuTestCPUID(false, arg);
}


static int
cpuTestGuestCPUID(const void *arg)
{
    return cpuTestCPUID(true, arg);
}


J
Jiri Denemark 已提交
638 639 640 641
static int
cpuTestCompareSignature(const struct data *data,
                        virCPUDataPtr hostData)
{
642 643
    g_autofree char *result = NULL;
    g_autofree char *sigStr = NULL;
J
Jiri Denemark 已提交
644 645 646 647 648 649 650
    unsigned long signature;
    unsigned int family;
    unsigned int model;
    unsigned int stepping;

    signature = virCPUx86DataGetSignature(hostData, &family, &model, &stepping);

651 652
    result = g_strdup_printf("%s/cputestdata/%s-cpuid-%s.sig", abs_srcdir,
                             virArchToString(data->arch), data->host);
J
Jiri Denemark 已提交
653

654 655 656
    sigStr = g_strdup_printf("%1$06lx\n" "family:   %2$3u (0x%2$02x)\n"
                             "model:    %3$3u (0x%3$02x)\n" "stepping: %4$3u (0x%4$02x)\n",
                             signature, family, model, stepping);
J
Jiri Denemark 已提交
657 658 659 660 661 662 663 664 665 666 667 668 669 670

    return virTestCompareToFile(sigStr, result);
}


static int
cpuTestCPUIDSignature(const void *arg)
{
    const struct data *data = arg;
    virCPUDataPtr hostData = NULL;
    char *hostFile = NULL;
    char *host = NULL;
    int ret = -1;

671 672
    hostFile = g_strdup_printf("%s/cputestdata/%s-cpuid-%s.xml", abs_srcdir,
                               virArchToString(data->arch), data->host);
J
Jiri Denemark 已提交
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687

    if (virTestLoadFile(hostFile, &host) < 0 ||
        !(hostData = virCPUDataParse(host)))
        goto cleanup;

    ret = cpuTestCompareSignature(data, hostData);

 cleanup:
    virCPUDataFree(hostData);
    VIR_FREE(hostFile);
    VIR_FREE(host);
    return ret;
}


688 689 690 691 692 693 694 695 696 697 698 699 700
static int
cpuTestUpdateLiveCompare(virArch arch,
                         virCPUDefPtr actual,
                         virCPUDefPtr expected)
{
    size_t i, j;
    int ret = 0;

    if (virCPUExpandFeatures(arch, actual) < 0 ||
        virCPUExpandFeatures(arch, expected) < 0)
        return -1;

    if (STRNEQ(actual->model, expected->model)) {
701
        VIR_TEST_VERBOSE("Actual CPU model '%s', expected '%s'",
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
                         actual->model, expected->model);
        return -1;
    }

    i = j = 0;
    while (i < actual->nfeatures || j < expected->nfeatures) {
        virCPUFeatureDefPtr featAct = NULL;
        virCPUFeatureDefPtr featExp = NULL;
        int cmp;

        if (i < actual->nfeatures)
            featAct = actual->features + i;

        if (j < expected->nfeatures)
            featExp = expected->features + j;

        /*
         * Act < Exp => cmp < 0 (missing entry in Exp)
         * Act = Exp => cmp = 0
         * Act > Exp => cmp > 0 (missing entry in Act)
         *
         * NULL > name for any name != NULL
         */
        if (featAct && featExp)
            cmp = strcmp(featAct->name, featExp->name);
        else
            cmp = featExp ? 1 : -1;

        if (cmp <= 0)
            i++;
        if (cmp >= 0)
            j++;

        /* Possible combinations of cmp, featAct->policy, and featExp->policy:
         *  cmp     Act     Exp     result
         * ---------------------------------
         *   0      dis     dis      ok
         *   0      dis     req     missing
         *   0      req     dis     extra
         *   0      req     req      ok
         * ---------------------------------
         *   -      dis      X       ok     # ignoring extra disabled features
         *   -      req      X      extra
         * ---------------------------------
         *   +       X      dis     extra
         *   +       X      req     missing
         */
        if ((cmp == 0 &&
             featAct->policy == VIR_CPU_FEATURE_DISABLE &&
             featExp->policy == VIR_CPU_FEATURE_REQUIRE) ||
            (cmp > 0 &&
             featExp->policy == VIR_CPU_FEATURE_REQUIRE)) {
754
            VIR_TEST_VERBOSE("Actual CPU lacks feature '%s'",
755 756 757 758 759 760 761 762 763 764 765 766
                             featExp->name);
            ret = -1;
            continue;
        }

        if ((cmp == 0 &&
             featAct->policy == VIR_CPU_FEATURE_REQUIRE &&
             featExp->policy == VIR_CPU_FEATURE_DISABLE) ||
            (cmp < 0 &&
             featAct->policy == VIR_CPU_FEATURE_REQUIRE) ||
            (cmp > 0 &&
             featExp->policy == VIR_CPU_FEATURE_DISABLE)) {
767
            VIR_TEST_VERBOSE("Actual CPU has extra feature '%s'",
768
                             cmp <= 0 ? featAct->name : featExp->name);
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
            ret = -1;
        }
    }

    return ret;
}


static int
cpuTestUpdateLive(const void *arg)
{
    const struct data *data = arg;
    char *cpuFile = NULL;
    virCPUDefPtr cpu = NULL;
    char *enabledFile = NULL;
    char *enabled = NULL;
    virCPUDataPtr enabledData = NULL;
    char *disabledFile = NULL;
    char *disabled = NULL;
    virCPUDataPtr disabledData = NULL;
    char *expectedFile = NULL;
    virCPUDefPtr expected = NULL;
791 792
    virDomainCapsCPUModelsPtr hvModels = NULL;
    virDomainCapsCPUModelsPtr models = NULL;
793 794
    int ret = -1;

795 796
    cpuFile = g_strdup_printf("cpuid-%s-guest", data->host);
    if (!(cpu = cpuTestLoadXML(data->arch, cpuFile)))
797 798
        goto cleanup;

799 800 801
    enabledFile = g_strdup_printf("%s/cputestdata/%s-cpuid-%s-enabled.xml",
                                  abs_srcdir, virArchToString(data->arch), data->host);
    if (virTestLoadFile(enabledFile, &enabled) < 0 ||
802 803 804
        !(enabledData = virCPUDataParse(enabled)))
        goto cleanup;

805 806 807
    disabledFile = g_strdup_printf("%s/cputestdata/%s-cpuid-%s-disabled.xml",
                                   abs_srcdir, virArchToString(data->arch), data->host);
    if (virTestLoadFile(disabledFile, &disabled) < 0 ||
808 809 810
        !(disabledData = virCPUDataParse(disabled)))
        goto cleanup;

811 812
    expectedFile = g_strdup_printf("cpuid-%s-json", data->host);
    if (!(expected = cpuTestLoadXML(data->arch, expectedFile)))
813 814
        goto cleanup;

815 816 817 818 819 820 821 822 823 824
    /* In case the host CPU signature does not exactly match any CPU model from
     * cpu_map.xml, the CPU model we detect from CPUID may differ from the one
     * we compute by asking QEMU. Since this test expands both CPU models and
     * compares their features, we can try to translate the 'actual' CPU to
     * use the CPU model from 'expected'.
     */
    if (STRNEQ(cpu->model, expected->model)) {
        virDomainCapsCPUModelPtr hvModel;
        char **blockers = NULL;
        virDomainCapsCPUUsable usable = VIR_DOMCAPS_CPU_USABLE_UNKNOWN;
825
        int rc;
826 827 828 829

        if (!(models = virDomainCapsCPUModelsNew(0)))
            goto cleanup;

830 831 832 833 834 835
        rc = cpuTestGetCPUModels(data, &hvModels);
        if (rc != 0) {
            ret = rc;
            goto cleanup;
        }

836 837 838 839 840 841 842
        hvModel = virDomainCapsCPUModelsGet(hvModels, expected->model);

        if (hvModel) {
            blockers = hvModel->blockers;
            usable = hvModel->usable;
        }

843
        if (virDomainCapsCPUModelsAdd(models, expected->model,
844 845 846 847 848 849 850 851 852 853 854
                                      usable, blockers) < 0)
            goto cleanup;

        cpu->fallback = VIR_CPU_FALLBACK_ALLOW;
        ignore_value(virCPUTranslate(data->arch, cpu, models));
        cpu->fallback = VIR_CPU_FALLBACK_FORBID;
    }

    if (virCPUUpdateLive(data->arch, cpu, enabledData, disabledData) < 0)
        goto cleanup;

855 856 857 858 859 860 861 862 863 864 865 866 867
    ret = cpuTestUpdateLiveCompare(data->arch, cpu, expected);

 cleanup:
    VIR_FREE(cpuFile);
    virCPUDefFree(cpu);
    VIR_FREE(enabledFile);
    VIR_FREE(enabled);
    virCPUDataFree(enabledData);
    VIR_FREE(disabledFile);
    VIR_FREE(disabled);
    virCPUDataFree(disabledData);
    VIR_FREE(expectedFile);
    virCPUDefFree(expected);
868 869
    virObjectUnref(hvModels);
    virObjectUnref(models);
870 871 872 873
    return ret;
}


874
#if WITH_QEMU && WITH_YAJL
J
Jiri Denemark 已提交
875 876 877 878
static int
cpuTestJSONCPUID(const void *arg)
{
    const struct data *data = arg;
879
    virQEMUCapsPtr qemuCaps = NULL;
J
Jiri Denemark 已提交
880 881 882 883
    virCPUDefPtr cpu = NULL;
    char *result = NULL;
    int ret = -1;

884
    result = g_strdup_printf("cpuid-%s-json", data->host);
J
Jiri Denemark 已提交
885

886
    if (!(qemuCaps = cpuTestMakeQEMUCaps(data)))
887 888
        goto cleanup;

889
    cpu = virCPUDefNew();
890
    cpu->arch = data->arch;
J
Jiri Denemark 已提交
891 892 893 894
    cpu->type = VIR_CPU_TYPE_GUEST;
    cpu->match = VIR_CPU_MATCH_EXACT;
    cpu->fallback = VIR_CPU_FALLBACK_FORBID;

895
    if (virQEMUCapsInitCPUModel(qemuCaps, VIR_DOMAIN_VIRT_KVM, cpu, false) != 0)
J
Jiri Denemark 已提交
896 897
        goto cleanup;

898
    ret = cpuTestCompareXML(data->arch, cpu, result);
J
Jiri Denemark 已提交
899 900

 cleanup:
901
    virObjectUnref(qemuCaps);
J
Jiri Denemark 已提交
902 903 904 905
    virCPUDefFree(cpu);
    VIR_FREE(result);
    return ret;
}
J
Jiri Denemark 已提交
906 907 908 909 910 911 912 913 914 915 916 917 918 919 920


static int
cpuTestJSONSignature(const void *arg)
{
    const struct data *data = arg;
    virQEMUCapsPtr qemuCaps = NULL;
    virCPUDataPtr hostData = NULL;
    qemuMonitorCPUModelInfoPtr modelInfo;
    int ret = -1;

    if (!(qemuCaps = cpuTestMakeQEMUCaps(data)))
        goto cleanup;

    modelInfo = virQEMUCapsGetCPUModelInfo(qemuCaps, VIR_DOMAIN_VIRT_KVM);
921
    if (!(hostData = virQEMUCapsGetCPUModelX86Data(qemuCaps, modelInfo, false)))
J
Jiri Denemark 已提交
922 923 924 925 926 927 928 929 930
        goto cleanup;

    ret = cpuTestCompareSignature(data, hostData);

 cleanup:
    virObjectUnref(qemuCaps);
    virCPUDataFree(hostData);
    return ret;
}
J
Jiri Denemark 已提交
931 932 933
#endif


934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
static const char *model486_list[]   = { "486", NULL };
static const char *nomodel_list[]    = { "nomodel", NULL };
static const char *models_list[]     = { "qemu64", "core2duo", "Nehalem", NULL };
static const char *haswell_list[]    = { "SandyBridge", "Haswell", NULL };
static const char *ppc_models_list[] = { "POWER6", "POWER7", "POWER8", NULL };

static virDomainCapsCPUModelsPtr
cpuTestInitModels(const char **list)
{
    virDomainCapsCPUModelsPtr cpus;
    const char **model;

    if (!(cpus = virDomainCapsCPUModelsNew(0)))
        return NULL;

    for (model = list; *model; model++) {
950
        if (virDomainCapsCPUModelsAdd(cpus, *model,
951 952 953 954 955 956 957 958 959 960 961
                                      VIR_DOMCAPS_CPU_USABLE_UNKNOWN, NULL) < 0)
            goto error;
    }

    return cpus;

 error:
    virObjectUnref(cpus);
    return NULL;
}

962 963

static int
E
Eric Blake 已提交
964
mymain(void)
965
{
966 967 968 969 970
    virDomainCapsCPUModelsPtr model486 = NULL;
    virDomainCapsCPUModelsPtr nomodel = NULL;
    virDomainCapsCPUModelsPtr models = NULL;
    virDomainCapsCPUModelsPtr haswell = NULL;
    virDomainCapsCPUModelsPtr ppc_models = NULL;
971 972
    int ret = 0;

973
#if WITH_QEMU && WITH_YAJL
J
Jiri Denemark 已提交
974 975 976 977 978 979
    if (qemuTestDriverInit(&driver) < 0)
        return EXIT_FAILURE;

    virEventRegisterDefaultImpl();
#endif

980 981 982 983 984 985 986 987 988
    if (!(model486 = cpuTestInitModels(model486_list)) ||
        !(nomodel = cpuTestInitModels(nomodel_list)) ||
        !(models = cpuTestInitModels(models_list)) ||
        !(haswell = cpuTestInitModels(haswell_list)) ||
        !(ppc_models = cpuTestInitModels(ppc_models_list))) {
        ret = -1;
        goto cleanup;
    }

989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
#define DO_TEST(arch, api, name, host, cpu, \
                models, flags, result) \
    do { \
        struct data data = { \
            arch, host, cpu, models, \
            models == NULL ? NULL : #models, \
            flags, result \
        }; \
        char *testLabel; \
        char *tmp; \
 \
        tmp = virTestLogContentAndReset(); \
        VIR_FREE(tmp); \
 \
1003 1004
        testLabel = g_strdup_printf("%s(%s): %s", #api, \
                                    virArchToString(arch), name); \
1005 1006 1007 1008 1009 1010
 \
        if (virTestRun(testLabel, api, &data) < 0) { \
            if (virTestGetDebug()) { \
                char *log; \
                if ((log = virTestLogContentAndReset()) && \
                     strlen(log) > 0) \
1011
                    VIR_TEST_DEBUG("\n%s", log); \
1012 1013 1014 1015 1016 1017
                VIR_FREE(log); \
            } \
            ret = -1; \
        } \
 \
        VIR_FREE(testLabel); \
1018 1019
    } while (0)

1020 1021 1022
#define DO_TEST_COMPARE(arch, host, cpu, result) \
    DO_TEST(arch, cpuTestCompare, \
            host "/" cpu " (" #result ")", \
1023
            host, cpu, NULL, 0, result)
1024

1025 1026 1027
#define DO_TEST_UPDATE_ONLY(arch, host, cpu) \
    DO_TEST(arch, cpuTestUpdate, \
            cpu " on " host, \
1028
            host, cpu, NULL, 0, 0)
J
Jiri Denemark 已提交
1029

1030 1031 1032 1033
#define DO_TEST_UPDATE(arch, host, cpu, result) \
    do { \
        DO_TEST_UPDATE_ONLY(arch, host, cpu); \
        DO_TEST_COMPARE(arch, host, host "+" cpu, result); \
1034 1035
    } while (0)

1036 1037 1038 1039 1040 1041 1042 1043
#define DO_TEST_BASELINE(arch, name, flags, result) \
    do { \
        const char *suffix = ""; \
        char *label; \
        if ((flags) & VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES) \
            suffix = " (expanded)"; \
        if ((flags) & VIR_CONNECT_BASELINE_CPU_MIGRATABLE) \
            suffix = " (migratable)"; \
1044 1045 1046
        label = g_strdup_printf("%s%s", name, suffix); \
        DO_TEST(arch, cpuTestBaseline, label, NULL, \
                "baseline-" name, NULL, flags, result); \
1047
        VIR_FREE(label); \
1048
    } while (0)
1049

1050 1051 1052
#define DO_TEST_HASFEATURE(arch, host, feature, result) \
    DO_TEST(arch, cpuTestHasFeature, \
            host "/" feature " (" #result ")", \
1053
            host, feature, NULL, 0, result)
1054

1055 1056 1057
#define DO_TEST_GUESTCPU(arch, host, cpu, models, result) \
    DO_TEST(arch, cpuTestGuestCPU, \
            host "/" cpu " (" #models ")", \
1058
            host, cpu, models, 0, result)
1059

1060
#if WITH_QEMU && WITH_YAJL
1061 1062 1063 1064 1065 1066 1067 1068 1069
# define DO_TEST_JSON(arch, host, json) \
    do { \
        if (json == JSON_MODELS) { \
            DO_TEST(arch, cpuTestGuestCPUID, host, host, \
                    NULL, NULL, 0, 0); \
        } \
        if (json != JSON_NONE) { \
            DO_TEST(arch, cpuTestJSONCPUID, host, host, \
                    NULL, NULL, json, 0); \
J
Jiri Denemark 已提交
1070 1071
            DO_TEST(arch, cpuTestJSONSignature, host, host, \
                    NULL, NULL, 0, 0); \
1072
        } \
J
Jiri Denemark 已提交
1073 1074
    } while (0)
#else
1075
# define DO_TEST_JSON(arch, host, json)
J
Jiri Denemark 已提交
1076 1077
#endif

1078 1079 1080 1081 1082 1083
#define DO_TEST_CPUID(arch, host, json) \
    do { \
        DO_TEST(arch, cpuTestHostCPUID, host, host, \
                NULL, NULL, 0, 0); \
        DO_TEST(arch, cpuTestGuestCPUID, host, host, \
                NULL, NULL, json, 0); \
J
Jiri Denemark 已提交
1084 1085
        DO_TEST(arch, cpuTestCPUIDSignature, host, host, \
                NULL, NULL, 0, 0); \
1086 1087 1088 1089 1090
        DO_TEST_JSON(arch, host, json); \
        if (json != JSON_NONE) { \
            DO_TEST(arch, cpuTestUpdateLive, host, host, \
                    NULL, NULL, json, 0); \
        } \
J
Jiri Denemark 已提交
1091 1092
    } while (0)

1093
    /* host to host comparison */
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "host", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "host-better", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "host-worse", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "host-amd-fake", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "host-incomp-arch", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "host-no-vendor", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host-no-vendor", "host", VIR_CPU_COMPARE_INCOMPATIBLE);

    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "host", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "host-better", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "host-worse", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "host-incomp-arch", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "host-no-vendor", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host-no-vendor", "host", VIR_CPU_COMPARE_INCOMPATIBLE);
1108

1109
    /* guest to host comparison */
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "bogus-model", VIR_CPU_COMPARE_ERROR);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "bogus-feature", VIR_CPU_COMPARE_ERROR);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "min", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "pentium3", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact-forbid", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact-forbid-extra", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact-disable", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact-disable2", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact-disable-extra", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact-require", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact-require-extra", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "exact-force", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "strict", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "strict-full", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "strict-disable", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "strict-force-extra", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "guest", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host", "pentium3-amd", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host-amd", "pentium3-amd", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host-worse", "penryn-force", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_X86_64, "host-SandyBridge", "exact-force-Haswell", VIR_CPU_COMPARE_IDENTICAL);

    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-strict", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-exact", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-legacy", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-legacy-incompatible", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-legacy-invalid", VIR_CPU_COMPARE_ERROR);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-compat-none", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-compat-valid", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-compat-invalid", VIR_CPU_COMPARE_ERROR);
    DO_TEST_COMPARE(VIR_ARCH_PPC64, "host", "guest-compat-incompatible", VIR_CPU_COMPARE_INCOMPATIBLE);
1142

1143 1144
    /* guest updates for migration
     * automatically compares host CPU with the result */
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
    DO_TEST_UPDATE(VIR_ARCH_X86_64, "host", "min", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_UPDATE(VIR_ARCH_X86_64, "host", "pentium3", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_UPDATE(VIR_ARCH_X86_64, "host", "guest", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_UPDATE(VIR_ARCH_X86_64, "host", "host-model", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_UPDATE(VIR_ARCH_X86_64, "host", "host-model-nofallback", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_UPDATE(VIR_ARCH_X86_64, "host-invtsc", "host-model", VIR_CPU_COMPARE_SUPERSET);
    DO_TEST_UPDATE_ONLY(VIR_ARCH_X86_64, "host", "host-passthrough");
    DO_TEST_UPDATE_ONLY(VIR_ARCH_X86_64, "host", "host-passthrough-features");

    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest-nofallback", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest-legacy", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest-legacy-incompatible", VIR_CPU_COMPARE_INCOMPATIBLE);
    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest-legacy-invalid", VIR_CPU_COMPARE_ERROR);
    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest-compat-none", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest-compat-valid", VIR_CPU_COMPARE_IDENTICAL);
    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest-compat-invalid", VIR_CPU_COMPARE_ERROR);
    DO_TEST_UPDATE(VIR_ARCH_PPC64, "host", "guest-compat-incompatible", VIR_CPU_COMPARE_INCOMPATIBLE);
1163

1164
    /* computing baseline CPUs */
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "incompatible-vendors", 0, -1);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "no-vendor", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "some-vendors", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "1", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "2", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "3", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "3", VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "4", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "4", VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "5", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "5", VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "6", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "6", VIR_CONNECT_BASELINE_CPU_MIGRATABLE, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "7", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_X86_64, "8", 0, 0);

    DO_TEST_BASELINE(VIR_ARCH_PPC64, "incompatible-vendors", 0, -1);
    DO_TEST_BASELINE(VIR_ARCH_PPC64, "no-vendor", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_PPC64, "incompatible-models", 0, -1);
    DO_TEST_BASELINE(VIR_ARCH_PPC64, "same-model", 0, 0);
    DO_TEST_BASELINE(VIR_ARCH_PPC64, "legacy", 0, -1);
1186

1187
    /* CPU features */
1188 1189 1190 1191 1192 1193
    DO_TEST_HASFEATURE(VIR_ARCH_X86_64, "host", "vmx", YES);
    DO_TEST_HASFEATURE(VIR_ARCH_X86_64, "host", "lm", YES);
    DO_TEST_HASFEATURE(VIR_ARCH_X86_64, "host", "sse4.1", YES);
    DO_TEST_HASFEATURE(VIR_ARCH_X86_64, "host", "3dnowext", NO);
    DO_TEST_HASFEATURE(VIR_ARCH_X86_64, "host", "skinit", NO);
    DO_TEST_HASFEATURE(VIR_ARCH_X86_64, "host", "foo", FAIL);
1194 1195

    /* computing guest data and decoding the data into a guest CPU XML */
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "guest", NULL, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host-better", "pentium3", NULL, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host-worse", "guest", NULL, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "strict-force-extra", NULL, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "penryn-force", NULL, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "guest", model486, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "guest", models, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "guest", nomodel, -1);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "guest-nofallback", models, -1);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "host+host-model", models, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host", "host+host-model-nofallback", models, -1);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host-Haswell-noTSX", "Haswell", haswell, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host-Haswell-noTSX", "Haswell-noTSX", haswell, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host-Haswell-noTSX", "Haswell-noTSX-nofallback", haswell, -1);
    DO_TEST_GUESTCPU(VIR_ARCH_X86_64, "host-Haswell-noTSX", "Haswell-noTSX", NULL, 0);

    DO_TEST_GUESTCPU(VIR_ARCH_PPC64, "host", "guest", ppc_models, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_PPC64, "host", "guest-nofallback", ppc_models, -1);
    DO_TEST_GUESTCPU(VIR_ARCH_PPC64, "host", "guest-legacy", ppc_models, 0);
    DO_TEST_GUESTCPU(VIR_ARCH_PPC64, "host", "guest-legacy-incompatible", ppc_models, -1);
    DO_TEST_GUESTCPU(VIR_ARCH_PPC64, "host", "guest-legacy-invalid", ppc_models, -1);

1218 1219 1220
    DO_TEST_CPUID(VIR_ARCH_X86_64, "A10-5800K", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Atom-D510", JSON_NONE);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Atom-N450", JSON_NONE);
1221
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i5-650", JSON_MODELS_REQUIRED);
1222
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i5-2500", JSON_HOST);
1223
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i5-2540M", JSON_MODELS);
1224 1225 1226
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i5-4670T", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i5-6600", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-2600", JSON_HOST);
1227
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-2600-xsaveopt", JSON_MODELS_REQUIRED);
1228 1229 1230 1231 1232 1233 1234
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-3520M", JSON_NONE);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-3740QM", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-3770", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-4600U", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-4510U", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-5600U", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-5600U-arat", JSON_HOST);
1235
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-5600U-ibrs", JSON_HOST);
1236
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-7600U", JSON_MODELS);
1237
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-7700", JSON_MODELS);
1238
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core-i7-8700", JSON_MODELS);
1239 1240
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core2-E6850", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Core2-Q9500", JSON_NONE);
1241
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Hygon-C86-7185-32-core", JSON_HOST);
1242
    DO_TEST_CPUID(VIR_ARCH_X86_64, "EPYC-7601-32-Core", JSON_HOST);
1243
    DO_TEST_CPUID(VIR_ARCH_X86_64, "EPYC-7601-32-Core-ibpb", JSON_MODELS_REQUIRED);
1244 1245 1246 1247 1248 1249 1250 1251 1252
    DO_TEST_CPUID(VIR_ARCH_X86_64, "FX-8150", JSON_NONE);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Opteron-1352", JSON_NONE);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Opteron-2350", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Opteron-6234", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Opteron-6282", JSON_NONE);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Pentium-P6100", JSON_NONE);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Phenom-B95", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Ryzen-7-1800X-Eight-Core", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-5110", JSON_NONE);
1253
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E3-1225-v5", JSON_MODELS);
1254
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E3-1245-v5", JSON_MODELS);
1255
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E5-2609-v3", JSON_MODELS);
1256
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E5-2623-v4", JSON_MODELS);
1257
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E5-2630-v3", JSON_HOST);
1258
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E5-2630-v4", JSON_MODELS);
1259
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E5-2650", JSON_MODELS);
1260
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E5-2650-v3", JSON_HOST);
1261
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E5-2650-v4", JSON_MODELS);
1262
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E7-4820", JSON_HOST);
1263
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E7-4830", JSON_MODELS_REQUIRED);
1264
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E7-8890-v3", JSON_MODELS);
1265
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-E7540", JSON_MODELS);
1266
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-Gold-5115", JSON_MODELS);
1267
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-Gold-6148", JSON_HOST);
1268
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-Platinum-8268", JSON_HOST);
1269 1270
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-W3520", JSON_HOST);
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Xeon-X5460", JSON_NONE);
1271
    DO_TEST_CPUID(VIR_ARCH_X86_64, "Ice-Lake-Server", JSON_MODELS);
1272

1273
 cleanup:
1274
#if WITH_QEMU && WITH_YAJL
J
Jiri Denemark 已提交
1275 1276 1277
    qemuTestDriverFree(&driver);
#endif

1278 1279 1280 1281 1282 1283
    virObjectUnref(model486);
    virObjectUnref(nomodel);
    virObjectUnref(models);
    virObjectUnref(haswell);
    virObjectUnref(ppc_models);

1284
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1285 1286
}

1287
VIR_TEST_MAIN(mymain)