tests/testutilsqemu.c

   1 #include <config.h>
   2 #ifdef WITH_QEMU
   3
   4 # include "testutilsqemu.h"
   5 # include "testutilshostcpus.h"
   6 # include "testutils.h"
   7 # include "viralloc.h"
   8 # include "cpu_conf.h"
   9 # include "qemu/qemu_driver.h"
  10 # include "qemu/qemu_domain.h"
  11 # define LIBVIRT_QEMU_CAPSPRIV_H_ALLOW
  12 # include "qemu/qemu_capspriv.h"
  13 # include "virstring.h"
  14 # include "virfilecache.h"
  15
  16 # define VIR_FROM_THIS VIR_FROM_QEMU
  17
  18 virCPUDefPtr cpuDefault;
  19 virCPUDefPtr cpuHaswell;
  20 virCPUDefPtr cpuPower8;
  21 virCPUDefPtr cpuPower9;
  22
  23 typedef enum {
  24     TEST_UTILS_QEMU_BIN_I686,
  25     TEST_UTILS_QEMU_BIN_X86_64,
  26     TEST_UTILS_QEMU_BIN_AARCH64,
  27     TEST_UTILS_QEMU_BIN_ARM,
  28     TEST_UTILS_QEMU_BIN_PPC64,
  29     TEST_UTILS_QEMU_BIN_PPC,
  30     TEST_UTILS_QEMU_BIN_RISCV32,
  31     TEST_UTILS_QEMU_BIN_RISCV64,
  32     TEST_UTILS_QEMU_BIN_S390X
  33 } QEMUBinType;
  34
  35 static const char *QEMUBinList[] = {
  36     "/usr/bin/qemu-system-i686",
  37     "/usr/bin/qemu-system-x86_64",
  38     "/usr/bin/qemu-system-aarch64",
  39     "/usr/bin/qemu-system-arm",
  40     "/usr/bin/qemu-system-ppc64",
  41     "/usr/bin/qemu-system-ppc",
  42     "/usr/bin/qemu-system-riscv32",
  43     "/usr/bin/qemu-system-riscv64",
  44     "/usr/bin/qemu-system-s390x"
  45 };
  46
  47
  48 static virCapsGuestMachinePtr *testQemuAllocMachines(int *nmachines)
  49 {
  50     virCapsGuestMachinePtr *machines;
  51     static const char *const x86_machines[] = {
  52         "pc", "isapc"
  53     };
  54
  55     machines = virCapabilitiesAllocMachines(x86_machines,
  56                                             ARRAY_CARDINALITY(x86_machines));
  57     if (machines == NULL)
  58         return NULL;
  59
  60     *nmachines = ARRAY_CARDINALITY(x86_machines);
  61
  62     return machines;
  63 }
  64
  65 /* Newer versions of qemu have versioned machine types to allow
  66  * compatibility with older releases.
  67  * The 'pc' machine type is an alias of the newest machine type.
  68  */
  69 static virCapsGuestMachinePtr *testQemuAllocNewerMachines(int *nmachines)
  70 {
  71     virCapsGuestMachinePtr *machines;
  72     char *canonical;
  73     static const char *const x86_machines[] = {
  74         "pc-0.11", "pc", "pc-0.10", "isapc"
  75     };
  76
  77     if (VIR_STRDUP(canonical, x86_machines[0]) < 0)
  78         return NULL;
  79
  80     machines = virCapabilitiesAllocMachines(x86_machines,
  81                                             ARRAY_CARDINALITY(x86_machines));
  82     if (machines == NULL) {
  83         VIR_FREE(canonical);
  84         return NULL;
  85     }
  86
  87     machines[1]->canonical = canonical;
  88
  89     *nmachines = ARRAY_CARDINALITY(x86_machines);
  90
  91     return machines;
  92 }
  93
  94
  95 static int
  96 testQemuAddI686Guest(virCapsPtr caps)
  97 {
  98     int nmachines = 0;
  99     virCapsGuestMachinePtr *machines = NULL;
 100     virCapsGuestPtr guest;
 101
 102     if (!(machines = testQemuAllocMachines(&nmachines)))
 103         goto error;
 104
 105     if (!(guest = virCapabilitiesAddGuest(caps,
 106                                           VIR_DOMAIN_OSTYPE_HVM,
 107                                           VIR_ARCH_I686,
 108                                           QEMUBinList[TEST_UTILS_QEMU_BIN_I686],
 109                                           NULL,
 110                                           nmachines,
 111                                           machines)))
 112         goto error;
 113
 114     if (!virCapabilitiesAddGuestFeature(guest, "cpuselection", true, false))
 115         goto error;
 116
 117     machines = NULL;
 118
 119     if (!virCapabilitiesAddGuestDomain(guest,
 120                                        VIR_DOMAIN_VIRT_QEMU,
 121                                        NULL,
 122                                        NULL,
 123                                        0,
 124                                        NULL))
 125         goto error;
 126
 127     if (!(machines = testQemuAllocMachines(&nmachines)))
 128         goto error;
 129
 130     if (!virCapabilitiesAddGuestDomain(guest,
 131                                        VIR_DOMAIN_VIRT_KVM,
 132                                        QEMUBinList[TEST_UTILS_QEMU_BIN_I686],
 133                                        NULL,
 134                                        nmachines,
 135                                        machines))
 136         goto error;
 137
 138     return 0;
 139
 140  error:
 141     virCapabilitiesFreeMachines(machines, nmachines);
 142     return -1;
 143 }
 144
 145
 146 static int
 147 testQemuAddX86_64Guest(virCapsPtr caps)
 148 {
 149     int nmachines = 0;
 150     virCapsGuestMachinePtr *machines = NULL;
 151     virCapsGuestPtr guest;
 152
 153     if (!(machines = testQemuAllocNewerMachines(&nmachines)))
 154         goto error;
 155
 156     if (!(guest = virCapabilitiesAddGuest(caps,
 157                                           VIR_DOMAIN_OSTYPE_HVM,
 158                                           VIR_ARCH_X86_64,
 159                                           QEMUBinList[TEST_UTILS_QEMU_BIN_X86_64],
 160                                           NULL,
 161                                           nmachines,
 162                                           machines)))
 163         goto error;
 164
 165     if (!virCapabilitiesAddGuestFeature(guest, "cpuselection", true, false))
 166         goto error;
 167
 168     machines = NULL;
 169
 170     if (!virCapabilitiesAddGuestDomain(guest,
 171                                        VIR_DOMAIN_VIRT_QEMU,
 172                                        NULL,
 173                                        NULL,
 174                                        0,
 175                                        NULL))
 176         goto error;
 177
 178     if (!(machines = testQemuAllocMachines(&nmachines)))
 179         goto error;
 180
 181     if (!virCapabilitiesAddGuestDomain(guest,
 182                                        VIR_DOMAIN_VIRT_KVM,
 183                                        QEMUBinList[TEST_UTILS_QEMU_BIN_X86_64],
 184                                        NULL,
 185                                        nmachines,
 186                                        machines))
 187         goto error;
 188
 189     machines = NULL;
 190
 191     if (!virCapabilitiesAddGuestDomain(guest,
 192                                        VIR_DOMAIN_VIRT_KVM,
 193                                        QEMUBinList[TEST_UTILS_QEMU_BIN_X86_64],
 194                                        NULL,
 195                                        0,
 196                                        NULL))
 197         goto error;
 198
 199     return 0;
 200
 201  error:
 202     virCapabilitiesFreeMachines(machines, nmachines);
 203     return -1;
 204 }
 205
 206
 207 static int testQemuAddPPC64Guest(virCapsPtr caps)
 208 {
 209     static const char *machine[] = { "pseries" };
 210     virCapsGuestMachinePtr *machines = NULL;
 211     virCapsGuestPtr guest;
 212
 213     machines = virCapabilitiesAllocMachines(machine, 1);
 214     if (!machines)
 215         goto error;
 216
 217     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_PPC64,
 218                                     QEMUBinList[TEST_UTILS_QEMU_BIN_PPC64],
 219                                     NULL, 1, machines);
 220     if (!guest)
 221         goto error;
 222
 223     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 224         goto error;
 225     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_KVM,
 226                                        NULL, NULL, 0, NULL))
 227         goto error;
 228
 229     return 0;
 230
 231  error:
 232     /* No way to free a guest? */
 233     virCapabilitiesFreeMachines(machines, 1);
 234     return -1;
 235 }
 236
 237 static int testQemuAddPPC64LEGuest(virCapsPtr caps)
 238 {
 239     static const char *machine[] = { "pseries" };
 240     virCapsGuestMachinePtr *machines = NULL;
 241     virCapsGuestPtr guest;
 242
 243     machines = virCapabilitiesAllocMachines(machine, 1);
 244     if (!machines)
 245         goto error;
 246
 247     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_PPC64LE,
 248                                     QEMUBinList[TEST_UTILS_QEMU_BIN_PPC64],
 249                                     NULL, 1, machines);
 250     if (!guest)
 251         goto error;
 252
 253     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 254         goto error;
 255     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_KVM,
 256                                        NULL, NULL, 0, NULL))
 257         goto error;
 258
 259     return 0;
 260
 261  error:
 262     /* No way to free a guest? */
 263     virCapabilitiesFreeMachines(machines, 1);
 264     return -1;
 265 }
 266
 267 static int testQemuAddPPCGuest(virCapsPtr caps)
 268 {
 269     static const char *machine[] = { "g3beige",
 270                                      "mac99",
 271                                      "prep",
 272                                      "ppce500" };
 273     virCapsGuestMachinePtr *machines = NULL;
 274     virCapsGuestPtr guest;
 275
 276     machines = virCapabilitiesAllocMachines(machine, 1);
 277     if (!machines)
 278         goto error;
 279
 280     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_PPC,
 281                                     QEMUBinList[TEST_UTILS_QEMU_BIN_PPC],
 282                                     NULL, 1, machines);
 283     if (!guest)
 284         goto error;
 285
 286     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 287         goto error;
 288     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_KVM,
 289                                        NULL, NULL, 0, NULL))
 290         goto error;
 291
 292     return 0;
 293
 294  error:
 295     /* No way to free a guest? */
 296     virCapabilitiesFreeMachines(machines, 1);
 297     return -1;
 298 }
 299
 300 static int testQemuAddRISCV32Guest(virCapsPtr caps)
 301 {
 302     static const char *names[] = { "spike_v1.10",
 303                                    "spike_v1.9.1",
 304                                    "sifive_e",
 305                                    "virt",
 306                                    "sifive_u" };
 307     static const int nmachines = ARRAY_CARDINALITY(names);
 308     virCapsGuestMachinePtr *machines = NULL;
 309     virCapsGuestPtr guest;
 310
 311     machines = virCapabilitiesAllocMachines(names, nmachines);
 312     if (!machines)
 313         goto error;
 314
 315     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_RISCV32,
 316                                     QEMUBinList[TEST_UTILS_QEMU_BIN_RISCV32],
 317                                     NULL, nmachines, machines);
 318     if (!guest)
 319         goto error;
 320
 321     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 322         goto error;
 323
 324     return 0;
 325
 326  error:
 327     virCapabilitiesFreeMachines(machines, nmachines);
 328     return -1;
 329 }
 330
 331 static int testQemuAddRISCV64Guest(virCapsPtr caps)
 332 {
 333     static const char *names[] = { "spike_v1.10",
 334                                    "spike_v1.9.1",
 335                                    "sifive_e",
 336                                    "virt",
 337                                    "sifive_u" };
 338     static const int nmachines = ARRAY_CARDINALITY(names);
 339     virCapsGuestMachinePtr *machines = NULL;
 340     virCapsGuestPtr guest;
 341
 342     machines = virCapabilitiesAllocMachines(names, nmachines);
 343     if (!machines)
 344         goto error;
 345
 346     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_RISCV64,
 347                                     QEMUBinList[TEST_UTILS_QEMU_BIN_RISCV64],
 348                                     NULL, nmachines, machines);
 349     if (!guest)
 350         goto error;
 351
 352     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 353         goto error;
 354
 355     return 0;
 356
 357  error:
 358     virCapabilitiesFreeMachines(machines, nmachines);
 359     return -1;
 360 }
 361
 362 static int testQemuAddS390Guest(virCapsPtr caps)
 363 {
 364     static const char *s390_machines[] = { "s390-virtio",
 365                                            "s390-ccw-virtio" };
 366     virCapsGuestMachinePtr *machines = NULL;
 367     virCapsGuestPtr guest;
 368
 369     machines = virCapabilitiesAllocMachines(s390_machines,
 370                                             ARRAY_CARDINALITY(s390_machines));
 371     if (!machines)
 372         goto error;
 373
 374     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_S390X,
 375                                     QEMUBinList[TEST_UTILS_QEMU_BIN_S390X],
 376                                     NULL,
 377                                     ARRAY_CARDINALITY(s390_machines),
 378                                     machines);
 379     if (!guest)
 380         goto error;
 381
 382     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 383         goto error;
 384     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_KVM,
 385                                        NULL, NULL, 0, NULL))
 386         goto error;
 387
 388     return 0;
 389
 390  error:
 391     virCapabilitiesFreeMachines(machines, ARRAY_CARDINALITY(s390_machines));
 392     return -1;
 393 }
 394
 395 static int testQemuAddArm6Guest(virCapsPtr caps)
 396 {
 397     static const char *machines[] = { "versatilepb" };
 398     virCapsGuestMachinePtr *capsmachines = NULL;
 399     virCapsGuestPtr guest;
 400
 401     capsmachines = virCapabilitiesAllocMachines(machines,
 402                                                 ARRAY_CARDINALITY(machines));
 403     if (!capsmachines)
 404         goto error;
 405
 406     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_ARMV6L,
 407                                     QEMUBinList[TEST_UTILS_QEMU_BIN_ARM],
 408                                     NULL,
 409                                     ARRAY_CARDINALITY(machines),
 410                                     capsmachines);
 411     if (!guest)
 412         goto error;
 413
 414     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 415         goto error;
 416     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_KVM,
 417                                        NULL, NULL, 0, NULL))
 418         goto error;
 419
 420     return 0;
 421
 422  error:
 423     virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));
 424     return -1;
 425 }
 426
 427 static int testQemuAddArm7Guest(virCapsPtr caps)
 428 {
 429     static const char *machines[] = { "vexpress-a9",
 430                                       "vexpress-a15",
 431                                       "versatilepb" };
 432     virCapsGuestMachinePtr *capsmachines = NULL;
 433     virCapsGuestPtr guest;
 434
 435     capsmachines = virCapabilitiesAllocMachines(machines,
 436                                                 ARRAY_CARDINALITY(machines));
 437     if (!capsmachines)
 438         goto error;
 439
 440     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_ARMV7L,
 441                                     QEMUBinList[TEST_UTILS_QEMU_BIN_ARM],
 442                                     NULL,
 443                                     ARRAY_CARDINALITY(machines),
 444                                     capsmachines);
 445     if (!guest)
 446         goto error;
 447
 448     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 449         goto error;
 450     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_KVM,
 451                                        NULL, NULL, 0, NULL))
 452         goto error;
 453
 454     return 0;
 455
 456  error:
 457     virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));
 458     return -1;
 459 }
 460
 461 static int testQemuAddAARCH64Guest(virCapsPtr caps)
 462 {
 463     static const char *machines[] = { "virt"};
 464     virCapsGuestMachinePtr *capsmachines = NULL;
 465     virCapsGuestPtr guest;
 466
 467     capsmachines = virCapabilitiesAllocMachines(machines,
 468                                                 ARRAY_CARDINALITY(machines));
 469     if (!capsmachines)
 470         goto error;
 471
 472     guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_AARCH64,
 473                                     QEMUBinList[TEST_UTILS_QEMU_BIN_AARCH64],
 474                                     NULL,
 475                                     ARRAY_CARDINALITY(machines),
 476                                     capsmachines);
 477     if (!guest)
 478         goto error;
 479
 480     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU, NULL, NULL, 0, NULL))
 481         goto error;
 482     if (!virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_KVM,
 483                                        NULL, NULL, 0, NULL))
 484         goto error;
 485
 486     return 0;
 487
 488  error:
 489     virCapabilitiesFreeMachines(capsmachines, ARRAY_CARDINALITY(machines));
 490     return -1;
 491 }
 492
 493 virCapsPtr testQemuCapsInit(void)
 494 {
 495     virCapsPtr caps;
 496
 497     if (!(caps = virCapabilitiesNew(VIR_ARCH_X86_64, false, false)))
 498         return NULL;
 499
 500     /* Add dummy 'none' security_driver. This is equal to setting
 501      * security_driver = "none" in qemu.conf. */
 502     if (VIR_ALLOC_N(caps->host.secModels, 1) < 0)
 503         goto cleanup;
 504     caps->host.nsecModels = 1;
 505
 506     if (VIR_STRDUP(caps->host.secModels[0].model, "none") < 0 ||
 507         VIR_STRDUP(caps->host.secModels[0].doi, "0") < 0)
 508         goto cleanup;
 509
 510     if (!(cpuDefault = virCPUDefCopy(&cpuDefaultData)) ||
 511         !(cpuHaswell = virCPUDefCopy(&cpuHaswellData)) ||
 512         !(cpuPower8 = virCPUDefCopy(&cpuPower8Data)) ||
 513         !(cpuPower9 = virCPUDefCopy(&cpuPower9Data)))
 514         goto cleanup;
 515
 516     qemuTestSetHostCPU(caps, NULL);
 517
 518     /*
 519      * Build a NUMA topology with cell_id (NUMA node id
 520      * being 3(0 + 3),4(1 + 3), 5 and 6
 521      */
 522     if (virTestCapsBuildNUMATopology(caps, 3) < 0)
 523         goto cleanup;
 524
 525     if (testQemuAddI686Guest(caps) < 0)
 526         goto cleanup;
 527
 528     if (testQemuAddX86_64Guest(caps) < 0)
 529         goto cleanup;
 530
 531     if (testQemuAddPPC64Guest(caps))
 532         goto cleanup;
 533
 534     if (testQemuAddPPC64LEGuest(caps))
 535         goto cleanup;
 536
 537     if (testQemuAddPPCGuest(caps))
 538         goto cleanup;
 539
 540     if (testQemuAddRISCV32Guest(caps) < 0)
 541         goto cleanup;
 542
 543     if (testQemuAddRISCV64Guest(caps) < 0)
 544         goto cleanup;
 545
 546     if (testQemuAddS390Guest(caps))
 547         goto cleanup;
 548
 549     if (testQemuAddArm6Guest(caps))
 550         goto cleanup;
 551
 552     if (testQemuAddArm7Guest(caps))
 553         goto cleanup;
 554
 555     if (testQemuAddAARCH64Guest(caps))
 556         goto cleanup;
 557
 558     if (virTestGetDebug()) {
 559         char *caps_str;
 560
 561         caps_str = virCapabilitiesFormatXML(caps);
 562         if (!caps_str)
 563             goto cleanup;
 564
 565         VIR_TEST_DEBUG("QEMU driver capabilities:\n%s", caps_str);
 566
 567         VIR_FREE(caps_str);
 568     }
 569
 570     return caps;
 571
 572  cleanup:
 573     caps->host.cpu = NULL;
 574     virCPUDefFree(cpuDefault);
 575     virCPUDefFree(cpuHaswell);
 576     virCPUDefFree(cpuPower8);
 577     virObjectUnref(caps);
 578     return NULL;
 579 }
 580
 581
 582 void
 583 qemuTestSetHostArch(virCapsPtr caps,
 584                     virArch arch)
 585 {
 586     if (arch == VIR_ARCH_NONE)
 587         arch = VIR_ARCH_X86_64;
 588     caps->host.arch = arch;
 589     qemuTestSetHostCPU(caps, NULL);
 590 }
 591
 592
 593 void
 594 qemuTestSetHostCPU(virCapsPtr caps,
 595                    virCPUDefPtr cpu)
 596 {
 597     virArch arch = caps->host.arch;
 598
 599     if (!cpu) {
 600         if (ARCH_IS_X86(arch))
 601             cpu = cpuDefault;
 602         else if (ARCH_IS_PPC64(arch))
 603             cpu = cpuPower8;
 604     }
 605
 606     unsetenv("VIR_TEST_MOCK_FAKE_HOST_CPU");
 607     if (cpu) {
 608         caps->host.arch = cpu->arch;
 609         if (cpu->model)
 610             setenv("VIR_TEST_MOCK_FAKE_HOST_CPU", cpu->model, 1);
 611     }
 612     caps->host.cpu = cpu;
 613 }
 614
 615
 616 virQEMUCapsPtr
 617 qemuTestParseCapabilitiesArch(virArch arch,
 618                               const char *capsFile)
 619 {
 620     virQEMUCapsPtr qemuCaps = NULL;
 621
 622     if (!(qemuCaps = virQEMUCapsNew()) ||
 623         virQEMUCapsLoadCache(arch, qemuCaps, capsFile) < 0)
 624         goto error;
 625
 626     return qemuCaps;
 627
 628  error:
 629     virObjectUnref(qemuCaps);
 630     return NULL;
 631 }
 632
 633
 634 virQEMUCapsPtr
 635 qemuTestParseCapabilities(virCapsPtr caps,
 636                           const char *capsFile)
 637 {
 638     if (!caps)
 639         return NULL;
 640
 641     return qemuTestParseCapabilitiesArch(caps->host.arch, capsFile);
 642 }
 643
 644
 645 void qemuTestDriverFree(virQEMUDriver *driver)
 646 {
 647     virMutexDestroy(&driver->lock);
 648     if (driver->config) {
 649         virFileDeleteTree(driver->config->stateDir);
 650         virFileDeleteTree(driver->config->configDir);
 651     }
 652     virObjectUnref(driver->qemuCapsCache);
 653     virObjectUnref(driver->xmlopt);
 654     virObjectUnref(driver->caps);
 655     virObjectUnref(driver->config);
 656     virObjectUnref(driver->securityManager);
 657 }
 658
 659 int qemuTestCapsCacheInsert(virFileCachePtr cache,
 660                             virQEMUCapsPtr caps)
 661 {
 662     size_t i;
 663     virQEMUCapsPtr tmpCaps;
 664
 665     if (caps) {
 666         tmpCaps = caps;
 667     } else {
 668         if (!(tmpCaps = virQEMUCapsNew()))
 669             return -ENOMEM;
 670     }
 671
 672     for (i = 0; i < ARRAY_CARDINALITY(QEMUBinList); i++) {
 673         virObjectRef(tmpCaps);
 674         if (virFileCacheInsertData(cache, QEMUBinList[i], tmpCaps) < 0) {
 675             virObjectUnref(tmpCaps);
 676             return -1;
 677         }
 678     }
 679
 680     if (!caps)
 681         virObjectUnref(tmpCaps);
 682
 683     return 0;
 684 }
 685
 686
 687 # define STATEDIRTEMPLATE abs_builddir "/qemustatedir-XXXXXX"
 688 # define CONFIGDIRTEMPLATE abs_builddir "/qemuconfigdir-XXXXXX"
 689
 690 int qemuTestDriverInit(virQEMUDriver *driver)
 691 {
 692     virSecurityManagerPtr mgr = NULL;
 693     char statedir[] = STATEDIRTEMPLATE;
 694     char configdir[] = CONFIGDIRTEMPLATE;
 695
 696     memset(driver, 0, sizeof(*driver));
 697
 698     if (virMutexInit(&driver->lock) < 0)
 699         return -1;
 700
 701     driver->config = virQEMUDriverConfigNew(false);
 702     if (!driver->config)
 703         goto error;
 704
 705     /* Do this early so that qemuTestDriverFree() doesn't see (unlink) the real
 706      * dirs. */
 707     VIR_FREE(driver->config->stateDir);
 708     VIR_FREE(driver->config->configDir);
 709
 710     /* Overwrite some default paths so it's consistent for tests. */
 711     VIR_FREE(driver->config->libDir);
 712     VIR_FREE(driver->config->channelTargetDir);
 713     if (VIR_STRDUP(driver->config->libDir, "/tmp/lib") < 0 ||
 714         VIR_STRDUP(driver->config->channelTargetDir, "/tmp/channel") < 0)
 715         goto error;
 716
 717     if (!mkdtemp(statedir)) {
 718         virFilePrintf(stderr, "Cannot create fake stateDir");
 719         goto error;
 720     }
 721
 722     if (VIR_STRDUP(driver->config->stateDir, statedir) < 0) {
 723         rmdir(statedir);
 724         goto error;
 725     }
 726
 727     if (!mkdtemp(configdir)) {
 728         virFilePrintf(stderr, "Cannot create fake configDir");
 729         goto error;
 730     }
 731
 732     if (VIR_STRDUP(driver->config->configDir, configdir) < 0) {
 733         rmdir(configdir);
 734         goto error;
 735     }
 736
 737     driver->caps = testQemuCapsInit();
 738     if (!driver->caps)
 739         goto error;
 740
 741     /* Using /dev/null for libDir and cacheDir automatically produces errors
 742      * upon attempt to use any of them */
 743     driver->qemuCapsCache = virQEMUCapsCacheNew("/dev/null", "/dev/null", 0, 0);
 744     if (!driver->qemuCapsCache)
 745         goto error;
 746
 747     driver->xmlopt = virQEMUDriverCreateXMLConf(driver);
 748     if (!driver->xmlopt)
 749         goto error;
 750
 751     if (qemuTestCapsCacheInsert(driver->qemuCapsCache, NULL) < 0)
 752         goto error;
 753
 754     if (!(mgr = virSecurityManagerNew("none", "qemu",
 755                                       VIR_SECURITY_MANAGER_PRIVILEGED)))
 756         goto error;
 757     if (!(driver->securityManager = virSecurityManagerNewStack(mgr)))
 758         goto error;
 759
 760     return 0;
 761
 762  error:
 763     virObjectUnref(mgr);
 764     qemuTestDriverFree(driver);
 765     return -1;
 766 }
 767
 768 int
 769 testQemuCapsSetGIC(virQEMUCapsPtr qemuCaps,
 770                    int gic)
 771 {
 772     virGICCapability *gicCapabilities = NULL;
 773     size_t ngicCapabilities = 0;
 774     int ret = -1;
 775
 776     if (VIR_ALLOC_N(gicCapabilities, 2) < 0)
 777         goto out;
 778
 779 # define IMPL_BOTH \
 780          VIR_GIC_IMPLEMENTATION_KERNEL|VIR_GIC_IMPLEMENTATION_EMULATED
 781
 782     if (gic & GIC_V2) {
 783         gicCapabilities[ngicCapabilities].version = VIR_GIC_VERSION_2;
 784         gicCapabilities[ngicCapabilities].implementation = IMPL_BOTH;
 785         ngicCapabilities++;
 786     }
 787     if (gic & GIC_V3) {
 788         gicCapabilities[ngicCapabilities].version = VIR_GIC_VERSION_3;
 789         gicCapabilities[ngicCapabilities].implementation = IMPL_BOTH;
 790         ngicCapabilities++;
 791     }
 792
 793 # undef IMPL_BOTH
 794
 795     virQEMUCapsSetGICCapabilities(qemuCaps,
 796                                   gicCapabilities, ngicCapabilities);
 797
 798     ret = 0;
 799
 800  out:
 801     return ret;
 802 }
 803
 804 #endif
 805
 806
 807 char *
 808 testQemuGetLatestCapsForArch(const char *arch,
 809                              const char *suffix)
 810 {
 811     struct dirent *ent;
 812     DIR *dir = NULL;
 813     int rc;
 814     char *fullsuffix = NULL;
 815     char *tmp = NULL;
 816     unsigned long maxver = 0;
 817     unsigned long ver;
 818     const char *maxname = NULL;
 819     char *ret = NULL;
 820
 821     if (virAsprintf(&fullsuffix, "%s.%s", arch, suffix) < 0)
 822         goto cleanup;
 823
 824     if (virDirOpen(&dir, TEST_QEMU_CAPS_PATH) < 0)
 825         goto cleanup;
 826
 827     while ((rc = virDirRead(dir, &ent, TEST_QEMU_CAPS_PATH)) > 0) {
 828         VIR_FREE(tmp);
 829
 830         if ((rc = VIR_STRDUP(tmp, STRSKIP(ent->d_name, "caps_"))) < 0)
 831             goto cleanup;
 832
 833         if (rc == 0)
 834             continue;
 835
 836         if (!virStringStripSuffix(tmp, fullsuffix))
 837             continue;
 838
 839         if (virParseVersionString(tmp, &ver, false) < 0) {
 840             VIR_TEST_DEBUG("skipping caps file '%s'\n", ent->d_name);
 841             continue;
 842         }
 843
 844         if (ver > maxver) {
 845             maxname = ent->d_name;
 846             maxver = ver;
 847         }
 848     }
 849
 850     if (rc < 0)
 851         goto cleanup;
 852
 853     if (!maxname) {
 854         VIR_TEST_VERBOSE("failed to find capabilities for '%s' in '%s'\n",
 855                          arch, TEST_QEMU_CAPS_PATH);
 856         goto cleanup;
 857     }
 858
 859     ignore_value(virAsprintf(&ret, "%s/%s", TEST_QEMU_CAPS_PATH, maxname));
 860
 861  cleanup:
 862     VIR_FREE(tmp);
 863     VIR_FREE(fullsuffix);
 864     virDirClose(&dir);
 865     return ret;
 866 }
 867
 868
 869 virHashTablePtr
 870 testQemuGetLatestCaps(void)
 871 {
 872     const char *archs[] = {
 873         "aarch64",
 874         "ppc64",
 875         "riscv64",
 876         "s390x",
 877         "x86_64",
 878     };
 879     virHashTablePtr capslatest;
 880     size_t i;
 881
 882     if (!(capslatest = virHashCreate(4, virHashValueFree)))
 883         goto error;
 884
 885     VIR_TEST_VERBOSE("\n");
 886
 887     for (i = 0; i < ARRAY_CARDINALITY(archs); ++i) {
 888         char *cap = testQemuGetLatestCapsForArch(archs[i], "xml");
 889
 890         if (!cap || virHashAddEntry(capslatest, archs[i], cap) < 0)
 891             goto error;
 892
 893         VIR_TEST_VERBOSE("latest caps for %s: %s\n", archs[i], cap);
 894     }
 895
 896     VIR_TEST_VERBOSE("\n");
 897     return capslatest;
 898
 899  error:
 900     virHashFree(capslatest);
 901     return NULL;
 902 }
 903
 904
 905 int
 906 testQemuCapsIterate(const char *suffix,
 907                     testQemuCapsIterateCallback callback,
 908                     void *opaque)
 909 {
 910     struct dirent *ent;
 911     DIR *dir = NULL;
 912     int rc;
 913     int ret = -1;
 914
 915     if (!callback)
 916         return 0;
 917
 918     if (virDirOpen(&dir, TEST_QEMU_CAPS_PATH) < 0)
 919         goto cleanup;
 920
 921     while ((rc = virDirRead(dir, &ent, TEST_QEMU_CAPS_PATH)) > 0) {
 922         char *tmp = ent->d_name;
 923         char *base = NULL;
 924         char *archName = NULL;
 925
 926         /* Strip the trailing suffix, moving on if it's not present */
 927         if (!virStringStripSuffix(tmp, suffix))
 928             continue;
 929
 930         /* Find the last dot, moving on if none is present */
 931         if (!(archName = strrchr(tmp, '.')))
 932             continue;
 933
 934         /* The base name is everything before the last dot, and
 935          * the architecture name everything after it */
 936         base = tmp;
 937         archName[0] = '\0';
 938         archName++;
 939
 940         /* Run the user-provided callback */
 941         if (callback(base, archName, opaque) < 0)
 942             goto cleanup;
 943     }
 944
 945     if (rc < 0)
 946         goto cleanup;
 947
 948     ret = 0;
 949
 950  cleanup:
 951     virDirClose(&dir);
 952
 953     return ret;
 954 }
 955
 956
 957 int
 958 testQemuInfoSetArgs(struct testQemuInfo *info,
 959                     virHashTablePtr capslatest, ...)
 960 {
 961     va_list argptr;
 962     testQemuInfoArgName argname;
 963     virQEMUCapsPtr qemuCaps = NULL;
 964     int gic = GIC_NONE;
 965     char *capsarch = NULL;
 966     char *capsver = NULL;
 967     VIR_AUTOFREE(char *) capsfile = NULL;
 968     int flag;
 969     int ret = -1;
 970
 971     va_start(argptr, capslatest);
 972     argname = va_arg(argptr, testQemuInfoArgName);
 973     while (argname != ARG_END) {
 974         switch (argname) {
 975         case ARG_QEMU_CAPS:
 976             if (qemuCaps || !(qemuCaps = virQEMUCapsNew()))
 977                 goto cleanup;
 978
 979             while ((flag = va_arg(argptr, int)) < QEMU_CAPS_LAST)
 980                 virQEMUCapsSet(qemuCaps, flag);
 981
 982             /* Some tests are run with NONE capabilities, which is just
 983              * another name for QEMU_CAPS_LAST. If that is the case the
 984              * arguments look like this :
 985              *
 986              *   ARG_QEMU_CAPS, NONE, QEMU_CAPS_LAST, ARG_END
 987              *
 988              * Fetch one argument more and if it is QEMU_CAPS_LAST then
 989              * break from the switch() to force getting next argument
 990              * in the line. If it is not QEMU_CAPS_LAST then we've
 991              * fetched real ARG_* and we must process it.
 992              */
 993             if ((flag = va_arg(argptr, int)) != QEMU_CAPS_LAST) {
 994                 argname = flag;
 995                 continue;
 996             }
 997
 998             break;
 999
1000         case ARG_GIC:
1001             gic = va_arg(argptr, int);
1002             break;
1003
1004         case ARG_MIGRATE_FROM:
1005             info->migrateFrom = va_arg(argptr, char *);
1006             break;
1007
1008         case ARG_MIGRATE_FD:
1009             info->migrateFd = va_arg(argptr, int);
1010             break;
1011
1012         case ARG_FLAGS:
1013             info->flags = va_arg(argptr, int);
1014             break;
1015
1016         case ARG_PARSEFLAGS:
1017             info->parseFlags = va_arg(argptr, int);
1018             break;
1019
1020         case ARG_CAPS_ARCH:
1021             capsarch = va_arg(argptr, char *);
1022             break;
1023
1024         case ARG_CAPS_VER:
1025             capsver = va_arg(argptr, char *);
1026             break;
1027
1028         case ARG_END:
1029         default:
1030             fprintf(stderr, "Unexpected test info argument");
1031             goto cleanup;
1032         }
1033
1034         argname = va_arg(argptr, testQemuInfoArgName);
1035     }
1036
1037     if (!!capsarch ^ !!capsver) {
1038         fprintf(stderr, "ARG_CAPS_ARCH and ARG_CAPS_VER "
1039                         "must be specified together.\n");
1040         goto cleanup;
1041     }
1042
1043     if (qemuCaps && (capsarch || capsver)) {
1044         fprintf(stderr, "ARG_QEMU_CAPS can not be combined with ARG_CAPS_ARCH "
1045                         "or ARG_CAPS_VER\n");
1046         goto cleanup;
1047     }
1048
1049     if (!qemuCaps && capsarch && capsver) {
1050         bool stripmachinealiases = false;
1051
1052         if (STREQ(capsver, "latest")) {
1053             if (VIR_STRDUP(capsfile, virHashLookup(capslatest, capsarch)) < 0)
1054                 goto cleanup;
1055             stripmachinealiases = true;
1056         } else if (virAsprintf(&capsfile, "%s/caps_%s.%s.xml",
1057                                TEST_QEMU_CAPS_PATH, capsver, capsarch) < 0) {
1058             goto cleanup;
1059         }
1060
1061         if (!(qemuCaps = qemuTestParseCapabilitiesArch(virArchFromString(capsarch),
1062                                                        capsfile))) {
1063             goto cleanup;
1064         }
1065
1066         if (stripmachinealiases)
1067             virQEMUCapsStripMachineAliases(qemuCaps);
1068         info->flags |= FLAG_REAL_CAPS;
1069     }
1070
1071     if (!qemuCaps) {
1072         fprintf(stderr, "No qemuCaps generated\n");
1073         goto cleanup;
1074     }
1075     VIR_STEAL_PTR(info->qemuCaps, qemuCaps);
1076
1077     if (gic != GIC_NONE && testQemuCapsSetGIC(info->qemuCaps, gic) < 0)
1078         goto cleanup;
1079
1080     ret = 0;
1081
1082  cleanup:
1083     virObjectUnref(qemuCaps);
1084     va_end(argptr);
1085
1086     return ret;
1087 }
1088
1089
1090 void
1091 testQemuInfoClear(struct testQemuInfo *info)
1092 {
1093     VIR_FREE(info->infile);
1094     VIR_FREE(info->outfile);
1095     virObjectUnref(info->qemuCaps);
1096 }