1 /* 2 * qemu_domain.h: QEMU domain private state 3 * 4 * Copyright (C) 2006-2019 Red Hat, Inc. 5 * Copyright (C) 2006 Daniel P. Berrange 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library. If not, see 19 * <http://www.gnu.org/licenses/>. 20 */ 21 22 #pragma once 23 24 #include <glib-object.h> 25 #include "virthread.h" 26 #include "vircgroup.h" 27 #include "virperf.h" 28 #include "domain_addr.h" 29 #include "domain_conf.h" 30 #include "snapshot_conf.h" 31 #include "qemu_monitor.h" 32 #include "qemu_agent.h" 33 #include "qemu_blockjob.h" 34 #include "qemu_domainjob.h" 35 #include "qemu_conf.h" 36 #include "qemu_capabilities.h" 37 #include "qemu_migration_params.h" 38 #include "qemu_slirp.h" 39 #include "virmdev.h" 40 #include "virchrdev.h" 41 #include "virobject.h" 42 #include "logging/log_manager.h" 43 #include "virdomainmomentobjlist.h" 44 #include "virenum.h" 45 #include "vireventthread.h" 46 47 #define QEMU_DOMAIN_FORMAT_LIVE_FLAGS \ 48 (VIR_DOMAIN_XML_SECURE) 49 50 #if ULONG_MAX == 4294967295 51 /* QEMU has a 64-bit limit, but we are limited by our historical choice of 52 * representing bandwidth in a long instead of a 64-bit int. */ 53 # define QEMU_DOMAIN_MIG_BANDWIDTH_MAX ULONG_MAX 54 #else 55 # define QEMU_DOMAIN_MIG_BANDWIDTH_MAX (INT64_MAX / (1024 * 1024)) 56 #endif 57 58 typedef void (*qemuDomainCleanupCallback)(virQEMUDriver *driver, 59 virDomainObj *vm); 60 61 #define QEMU_DOMAIN_MASTER_KEY_LEN 32 /* 32 bytes for 256 bit random key */ 62 63 void 64 qemuDomainObjSaveStatus(virQEMUDriver *driver, 65 virDomainObj *obj); 66 67 void qemuDomainSaveStatus(virDomainObj *obj); 68 void qemuDomainSaveConfig(virDomainObj *obj); 69 70 71 /* helper data types for async device unplug */ 72 typedef enum { 73 QEMU_DOMAIN_UNPLUGGING_DEVICE_STATUS_NONE = 0, 74 QEMU_DOMAIN_UNPLUGGING_DEVICE_STATUS_OK, 75 QEMU_DOMAIN_UNPLUGGING_DEVICE_STATUS_GUEST_REJECTED, 76 } qemuDomainUnpluggingDeviceStatus; 77 78 typedef struct _qemuDomainUnpluggingDevice qemuDomainUnpluggingDevice; 79 struct _qemuDomainUnpluggingDevice { 80 const char *alias; 81 qemuDomainUnpluggingDeviceStatus status; 82 bool eventSeen; /* True if DEVICE_DELETED event arrived. */ 83 }; 84 85 86 #define QEMU_PROC_MOUNTS "/proc/mounts" 87 #define QEMU_DEVPREFIX "/dev/" 88 #define QEMU_DEV_VFIO "/dev/vfio/vfio" 89 #define QEMU_DEV_SEV "/dev/sev" 90 #define QEMU_DEVICE_MAPPER_CONTROL_PATH "/dev/mapper/control" 91 92 93 #define QEMU_DOMAIN_AES_IV_LEN 16 /* 16 bytes for 128 bit random */ 94 /* initialization vector */ 95 96 typedef struct _qemuDomainSecretInfo qemuDomainSecretInfo; 97 struct _qemuDomainSecretInfo { 98 char *username; 99 char *alias; /* generated alias for secret */ 100 char *iv; /* base64 encoded initialization vector */ 101 char *ciphertext; /* encoded/encrypted secret */ 102 }; 103 104 typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate; 105 struct _qemuDomainObjPrivate { 106 virQEMUDriver *driver; 107 108 qemuDomainJobObj job; 109 110 virBitmap *namespaces; 111 112 virEventThread *eventThread; 113 114 qemuMonitor *mon; 115 virDomainChrSourceDef *monConfig; 116 bool monError; 117 unsigned long long monStart; 118 int agentTimeout; 119 120 qemuAgent *agent; 121 bool agentError; 122 123 bool beingDestroyed; 124 char *pidfile; 125 126 virDomainPCIAddressSet *pciaddrs; 127 virDomainUSBAddressSet *usbaddrs; 128 129 virQEMUCaps *qemuCaps; 130 char *lockState; 131 132 bool fakeReboot; 133 bool pausedShutdown; 134 /* allowReboot: 135 * 136 * Unused with new QEMU versions which have QEMU_CAPS_SET_ACTION. 137 * 138 * Otherwise if it's set to VIR_TRISTATE_BOOL_YES, QEMU was started with 139 * -no-shutdown, and if set to VIR_TRISTATE_BOOL_NO qemu was started with 140 * -no-reboot instead. 141 */ 142 virTristateBool allowReboot; 143 144 int jobs_queued; 145 146 unsigned long migMaxBandwidth; 147 char *origname; 148 int nbdPort; /* Port used for migration with NBD */ 149 unsigned short migrationPort; 150 int preMigrationState; 151 152 virChrdevs *devs; 153 154 qemuDomainCleanupCallback *cleanupCallbacks; 155 size_t ncleanupCallbacks; 156 size_t ncleanupCallbacks_max; 157 158 virCgroup *cgroup; 159 160 virPerf *perf; 161 162 qemuDomainUnpluggingDevice unplug; 163 164 char **qemuDevices; /* NULL-terminated list of devices aliases known to QEMU */ 165 166 bool hookRun; /* true if there was a hook run over this domain */ 167 168 /* Bitmaps below hold data from the auto NUMA feature */ 169 virBitmap *autoNodeset; 170 virBitmap *autoCpuset; 171 172 bool signalIOError; /* true if the domain condition should be signalled on 173 I/O error */ 174 bool signalStop; /* true if the domain condition should be signalled on 175 QMP STOP event */ 176 char *machineName; 177 char *libDir; /* base path for per-domain files */ 178 char *channelTargetDir; /* base path for per-domain channel targets */ 179 180 /* random masterKey and length for encryption (not to be saved in our */ 181 /* private XML) - need to restore at process reconnect */ 182 uint8_t *masterKey; 183 size_t masterKeyLen; 184 185 /* note whether memory device alias does not correspond to slot number */ 186 bool memAliasOrderMismatch; 187 188 /* for migrations using TLS with a secret (not to be saved in our */ 189 /* private XML). */ 190 qemuDomainSecretInfo *migSecinfo; 191 192 /* CPU def used to start the domain when it differs from the one actually 193 * provided by QEMU. */ 194 virCPUDef *origCPU; 195 196 /* If true virtlogd is used as stdio handler for character devices. */ 197 bool chardevStdioLogd; 198 199 /* Tracks blockjob state for vm. Valid only while reconnecting to qemu. */ 200 virTristateBool reconnectBlockjobs; 201 202 /* Migration capabilities. Rechecked on reconnect, not to be saved in 203 * private XML. */ 204 virBitmap *migrationCaps; 205 206 /* true if qemu-pr-helper process is running for the domain */ 207 bool prDaemonRunning; 208 209 /* counter for generating node names for qemu disks */ 210 unsigned long long nodenameindex; 211 212 /* qemuProcessStartCPUs stores the reason for starting vCPUs here for the 213 * RESUME event handler to use it */ 214 virDomainRunningReason runningReason; 215 216 /* qemuProcessStopCPUs stores the reason for pausing vCPUs here for the 217 * STOP event handler to use it */ 218 virDomainPausedReason pausedReason; 219 220 /* true if libvirt remembers the original owner for files */ 221 bool rememberOwner; 222 223 /* true if global -mem-prealloc appears on cmd line */ 224 bool memPrealloc; 225 226 /* running block jobs */ 227 GHashTable *blockjobs; 228 229 bool disableSlirp; 230 231 /* Until we add full support for backing chains for pflash drives, these 232 * pointers hold the temporary virStorageSources for creating the -blockdev 233 * commandline for pflash drives. */ 234 virStorageSource *pflash0; 235 virStorageSource *pflash1; 236 237 /* running backup job */ 238 virDomainBackupDef *backup; 239 240 bool dbusDaemonRunning; 241 242 /* list of Ids to migrate */ 243 GSList *dbusVMStateIds; 244 /* true if -object dbus-vmstate was added */ 245 bool dbusVMState; 246 }; 247 248 #define QEMU_DOMAIN_PRIVATE(vm) \ 249 ((qemuDomainObjPrivate *) (vm)->privateData) 250 251 #define QEMU_DOMAIN_DISK_PRIVATE(disk) \ 252 ((qemuDomainDiskPrivate *) (disk)->privateData) 253 254 typedef struct _qemuDomainDiskPrivate qemuDomainDiskPrivate; 255 struct _qemuDomainDiskPrivate { 256 virObject parent; 257 258 /* ideally we want a smarter way to interlock block jobs on single qemu disk 259 * in the future, but for now we just disallow any concurrent job on a 260 * single disk */ 261 qemuBlockJobData *blockjob; 262 263 bool migrating; /* the disk is being migrated */ 264 virStorageSource *migrSource; /* disk source object used for NBD migration */ 265 266 /* information about the device */ 267 bool tray; /* device has tray */ 268 bool removable; /* device media can be removed/changed */ 269 270 char *qomName; /* QOM path of the disk (also refers to the block backend) */ 271 char *nodeCopyOnRead; /* nodename of the disk-wide copy-on-read blockdev layer */ 272 273 bool transientOverlayCreated; /* the overlay image of a transient disk was 274 created and the definition was updated */ 275 }; 276 277 #define QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src) \ 278 ((qemuDomainStorageSourcePrivate *) (src)->privateData) 279 280 typedef struct _qemuDomainStorageSourcePrivate qemuDomainStorageSourcePrivate; 281 struct _qemuDomainStorageSourcePrivate { 282 virObject parent; 283 284 /* data required for authentication to the storage source */ 285 qemuDomainSecretInfo *secinfo; 286 287 /* data required for decryption of encrypted storage source */ 288 qemuDomainSecretInfo *encinfo; 289 290 /* secure passthrough of the http cookie */ 291 qemuDomainSecretInfo *httpcookie; 292 293 /* key for decrypting TLS certificate */ 294 qemuDomainSecretInfo *tlsKeySecret; 295 }; 296 297 virObject *qemuDomainStorageSourcePrivateNew(void); 298 qemuDomainStorageSourcePrivate * 299 qemuDomainStorageSourcePrivateFetch(virStorageSource *src); 300 301 typedef struct _qemuDomainVcpuPrivate qemuDomainVcpuPrivate; 302 struct _qemuDomainVcpuPrivate { 303 virObject parent; 304 305 pid_t tid; /* vcpu thread id */ 306 int enable_id; /* order in which the vcpus were enabled in qemu */ 307 int qemu_id; /* ID reported by qemu as 'CPU' in query-cpus */ 308 char *alias; 309 virTristateBool halted; 310 311 /* copy of the data that qemu returned */ 312 virJSONValue *props; 313 314 /* information for hotpluggable cpus */ 315 char *type; 316 int socket_id; 317 int core_id; 318 int thread_id; 319 int node_id; 320 int vcpus; 321 }; 322 323 #define QEMU_DOMAIN_VCPU_PRIVATE(vcpu) \ 324 ((qemuDomainVcpuPrivate *) (vcpu)->privateData) 325 326 327 struct qemuDomainDiskInfo { 328 bool removable; 329 bool tray; 330 bool tray_open; 331 bool empty; 332 int io_status; 333 char *nodename; 334 }; 335 336 #define QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev) \ 337 ((qemuDomainChrSourcePrivate *) (dev)->privateData) 338 339 typedef struct _qemuDomainChrSourcePrivate qemuDomainChrSourcePrivate; 340 struct _qemuDomainChrSourcePrivate { 341 virObject parent; 342 343 /* for char devices using secret 344 * NB: *not* to be written to qemu domain object XML */ 345 qemuDomainSecretInfo *secinfo; 346 }; 347 348 349 typedef struct _qemuDomainVsockPrivate qemuDomainVsockPrivate; 350 struct _qemuDomainVsockPrivate { 351 virObject parent; 352 353 int vhostfd; 354 }; 355 356 357 #define QEMU_DOMAIN_VIDEO_PRIVATE(dev) \ 358 ((qemuDomainVideoPrivate *) (dev)->privateData) 359 360 typedef struct _qemuDomainVideoPrivate qemuDomainVideoPrivate; 361 struct _qemuDomainVideoPrivate { 362 virObject parent; 363 364 int vhost_user_fd; 365 }; 366 367 368 #define QEMU_DOMAIN_GRAPHICS_PRIVATE(dev) \ 369 ((qemuDomainGraphicsPrivate *) (dev)->privateData) 370 371 typedef struct _qemuDomainGraphicsPrivate qemuDomainGraphicsPrivate; 372 struct _qemuDomainGraphicsPrivate { 373 virObject parent; 374 375 char *tlsAlias; 376 qemuDomainSecretInfo *secinfo; 377 }; 378 379 380 #define QEMU_DOMAIN_NETWORK_PRIVATE(dev) \ 381 ((qemuDomainNetworkPrivate *) (dev)->privateData) 382 383 typedef struct _qemuDomainNetworkPrivate qemuDomainNetworkPrivate; 384 struct _qemuDomainNetworkPrivate { 385 virObject parent; 386 387 qemuSlirp *slirp; 388 }; 389 390 391 typedef enum { 392 QEMU_PROCESS_EVENT_WATCHDOG = 0, 393 QEMU_PROCESS_EVENT_GUESTPANIC, 394 QEMU_PROCESS_EVENT_DEVICE_DELETED, 395 QEMU_PROCESS_EVENT_NIC_RX_FILTER_CHANGED, 396 QEMU_PROCESS_EVENT_SERIAL_CHANGED, 397 QEMU_PROCESS_EVENT_BLOCK_JOB, 398 QEMU_PROCESS_EVENT_JOB_STATUS_CHANGE, 399 QEMU_PROCESS_EVENT_MONITOR_EOF, 400 QEMU_PROCESS_EVENT_PR_DISCONNECT, 401 QEMU_PROCESS_EVENT_RDMA_GID_STATUS_CHANGED, 402 QEMU_PROCESS_EVENT_GUEST_CRASHLOADED, 403 QEMU_PROCESS_EVENT_MEMORY_DEVICE_SIZE_CHANGE, 404 405 QEMU_PROCESS_EVENT_LAST 406 } qemuProcessEventType; 407 408 struct qemuProcessEvent { 409 virDomainObj *vm; 410 qemuProcessEventType eventType; 411 int action; 412 int status; 413 void *data; 414 }; 415 416 void qemuProcessEventFree(struct qemuProcessEvent *event); 417 418 #define QEMU_TYPE_DOMAIN_LOG_CONTEXT qemu_domain_log_context_get_type() 419 G_DECLARE_FINAL_TYPE(qemuDomainLogContext, qemu_domain_log_context, QEMU, DOMAIN_LOG_CONTEXT, GObject); 420 421 typedef struct _qemuDomainSaveCookie qemuDomainSaveCookie; 422 struct _qemuDomainSaveCookie { 423 virObject parent; 424 425 virCPUDef *cpu; 426 bool slirpHelper; 427 }; 428 429 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDomainSaveCookie, virObjectUnref); 430 431 typedef struct _qemuDomainXmlNsEnvTuple qemuDomainXmlNsEnvTuple; 432 struct _qemuDomainXmlNsEnvTuple { 433 char *name; 434 char *value; 435 }; 436 437 typedef struct _qemuDomainXmlNsDef qemuDomainXmlNsDef; 438 struct _qemuDomainXmlNsDef { 439 char **args; 440 441 unsigned int num_env; 442 qemuDomainXmlNsEnvTuple *env; 443 444 char **capsadd; 445 446 char **capsdel; 447 448 /* We deliberately keep this as a string so that it's parsed only when 449 * starting the VM to avoid any form of errors in the parser or when 450 * changing qemu versions. The knob is mainly for development/CI purposes */ 451 char *deprecationBehavior; 452 }; 453 454 455 typedef struct _qemuDomainJobPrivateMigrateTempBitmap qemuDomainJobPrivateMigrateTempBitmap; 456 struct _qemuDomainJobPrivateMigrateTempBitmap { 457 char *nodename; 458 char *bitmapname; 459 }; 460 461 void 462 qemuDomainJobPrivateMigrateTempBitmapFree(qemuDomainJobPrivateMigrateTempBitmap *bmp); 463 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDomainJobPrivateMigrateTempBitmap, qemuDomainJobPrivateMigrateTempBitmapFree); 464 465 466 typedef struct _qemuDomainJobPrivate qemuDomainJobPrivate; 467 struct _qemuDomainJobPrivate { 468 bool spiceMigration; /* we asked for spice migration and we 469 * should wait for it to finish */ 470 bool spiceMigrated; /* spice migration completed */ 471 bool dumpCompleted; /* dump completed */ 472 qemuMigrationParams *migParams; 473 GSList *migTempBitmaps; /* temporary block dirty bitmaps - qemuDomainJobPrivateMigrateTempBitmap */ 474 }; 475 476 int qemuDomainObjStartWorker(virDomainObj *dom); 477 void qemuDomainObjStopWorker(virDomainObj *dom); 478 479 virDomainObj *qemuDomainObjFromDomain(virDomainPtr domain); 480 481 qemuDomainSaveCookie *qemuDomainSaveCookieNew(virDomainObj *vm); 482 483 void qemuDomainEventFlush(int timer, void *opaque); 484 485 qemuMonitor *qemuDomainGetMonitor(virDomainObj *vm) 486 ATTRIBUTE_NONNULL(1); 487 void qemuDomainObjEnterMonitor(virQEMUDriver *driver, 488 virDomainObj *obj) 489 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); 490 int qemuDomainObjExitMonitor(virQEMUDriver *driver, 491 virDomainObj *obj) 492 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) 493 G_GNUC_WARN_UNUSED_RESULT; 494 int qemuDomainObjEnterMonitorAsync(virQEMUDriver *driver, 495 virDomainObj *obj, 496 qemuDomainAsyncJob asyncJob) 497 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT; 498 499 500 qemuAgent *qemuDomainObjEnterAgent(virDomainObj *obj) 501 ATTRIBUTE_NONNULL(1); 502 void qemuDomainObjExitAgent(virDomainObj *obj, qemuAgent *agent) 503 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); 504 505 506 void qemuDomainObjEnterRemote(virDomainObj *obj) 507 ATTRIBUTE_NONNULL(1); 508 int qemuDomainObjExitRemote(virDomainObj *obj, 509 bool checkActive) 510 ATTRIBUTE_NONNULL(1) G_GNUC_WARN_UNUSED_RESULT; 511 512 virDomainDef *qemuDomainDefCopy(virQEMUDriver *driver, 513 virQEMUCaps *qemuCaps, 514 virDomainDef *src, 515 unsigned int flags); 516 517 int qemuDomainDefFormatBuf(virQEMUDriver *driver, 518 virQEMUCaps *qemuCaps, 519 virDomainDef *vm, 520 unsigned int flags, 521 virBuffer *buf); 522 523 char *qemuDomainDefFormatXML(virQEMUDriver *driver, 524 virQEMUCaps *qemuCaps, 525 virDomainDef *vm, 526 unsigned int flags); 527 528 char *qemuDomainFormatXML(virQEMUDriver *driver, 529 virDomainObj *vm, 530 unsigned int flags); 531 532 char *qemuDomainDefFormatLive(virQEMUDriver *driver, 533 virQEMUCaps *qemuCaps, 534 virDomainDef *def, 535 virCPUDef *origCPU, 536 bool inactive, 537 bool compatible); 538 539 void qemuDomainObjTaint(virQEMUDriver *driver, 540 virDomainObj *obj, 541 virDomainTaintFlags taint, 542 qemuDomainLogContext *logCtxt); 543 544 void qemuDomainObjTaintMsg(virQEMUDriver *driver, 545 virDomainObj *obj, 546 virDomainTaintFlags taint, 547 qemuDomainLogContext *logCtxt, 548 const char *msg, 549 ...) G_GNUC_PRINTF(5, 6); 550 551 char **qemuDomainObjGetTainting(virQEMUDriver *driver, 552 virDomainObj *obj); 553 554 void qemuDomainObjCheckTaint(virQEMUDriver *driver, 555 virDomainObj *obj, 556 qemuDomainLogContext *logCtxt, 557 bool incomingMigration); 558 void qemuDomainObjCheckDiskTaint(virQEMUDriver *driver, 559 virDomainObj *obj, 560 virDomainDiskDef *disk, 561 qemuDomainLogContext *logCtxt); 562 void qemuDomainObjCheckHostdevTaint(virQEMUDriver *driver, 563 virDomainObj *obj, 564 virDomainHostdevDef *disk, 565 qemuDomainLogContext *logCtxt); 566 void qemuDomainObjCheckNetTaint(virQEMUDriver *driver, 567 virDomainObj *obj, 568 virDomainNetDef *net, 569 qemuDomainLogContext *logCtxt); 570 571 typedef enum { 572 QEMU_DOMAIN_LOG_CONTEXT_MODE_START, 573 QEMU_DOMAIN_LOG_CONTEXT_MODE_ATTACH, 574 QEMU_DOMAIN_LOG_CONTEXT_MODE_STOP, 575 } qemuDomainLogContextMode; 576 577 qemuDomainLogContext *qemuDomainLogContextNew(virQEMUDriver *driver, 578 virDomainObj *vm, 579 qemuDomainLogContextMode mode); 580 int qemuDomainLogContextWrite(qemuDomainLogContext *ctxt, 581 const char *fmt, ...) G_GNUC_PRINTF(2, 3); 582 ssize_t qemuDomainLogContextRead(qemuDomainLogContext *ctxt, 583 char **msg); 584 int qemuDomainLogContextGetWriteFD(qemuDomainLogContext *ctxt); 585 void qemuDomainLogContextMarkPosition(qemuDomainLogContext *ctxt); 586 587 virLogManager *qemuDomainLogContextGetManager(qemuDomainLogContext *ctxt); 588 589 int qemuDomainLogAppendMessage(virQEMUDriver *driver, 590 virDomainObj *vm, 591 const char *fmt, 592 ...) G_GNUC_PRINTF(3, 4); 593 594 const char *qemuFindQemuImgBinary(virQEMUDriver *driver); 595 596 int qemuDomainSnapshotWriteMetadata(virDomainObj *vm, 597 virDomainMomentObj *snapshot, 598 virDomainXMLOption *xmlopt, 599 const char *snapshotDir); 600 601 int qemuDomainSnapshotForEachQcow2(virQEMUDriver *driver, 602 virDomainDef *def, 603 virDomainMomentObj *snap, 604 const char *op, 605 bool try_all); 606 607 int qemuDomainSnapshotDiscard(virQEMUDriver *driver, 608 virDomainObj *vm, 609 virDomainMomentObj *snap, 610 bool update_current, 611 bool metadata_only); 612 613 typedef struct _virQEMUMomentRemove virQEMUMomentRemove; 614 struct _virQEMUMomentRemove { 615 virQEMUDriver *driver; 616 virDomainObj *vm; 617 int err; 618 bool metadata_only; 619 virDomainMomentObj *current; 620 bool found; 621 int (*momentDiscard)(virQEMUDriver *, virDomainObj *, 622 virDomainMomentObj *, bool, bool); 623 }; 624 625 int qemuDomainMomentDiscardAll(void *payload, 626 const char *name, 627 void *data); 628 629 int qemuDomainSnapshotDiscardAllMetadata(virQEMUDriver *driver, 630 virDomainObj *vm); 631 632 void qemuDomainRemoveInactive(virQEMUDriver *driver, 633 virDomainObj *vm); 634 635 void qemuDomainSetFakeReboot(virQEMUDriver *driver, 636 virDomainObj *vm, 637 bool value); 638 639 int qemuDomainCheckDiskStartupPolicy(virQEMUDriver *driver, 640 virDomainObj *vm, 641 size_t diskIndex, 642 bool cold_boot); 643 644 int qemuDomainCheckDiskPresence(virQEMUDriver *driver, 645 virDomainObj *vm, 646 unsigned int flags); 647 648 int qemuDomainStorageSourceValidateDepth(virStorageSource *src, 649 int add, 650 const char *diskdst); 651 652 int qemuDomainDetermineDiskChain(virQEMUDriver *driver, 653 virDomainObj *vm, 654 virDomainDiskDef *disk, 655 virStorageSource *disksrc, 656 bool report_broken); 657 658 bool qemuDomainDiskChangeSupported(virDomainDiskDef *disk, 659 virDomainDiskDef *orig_disk); 660 661 void qemuDomainGetImageIds(virQEMUDriverConfig *cfg, 662 virDomainObj *vm, 663 virStorageSource *src, 664 virStorageSource *parentSrc, 665 uid_t *uid, 666 gid_t *gid); 667 668 int qemuDomainStorageFileInit(virQEMUDriver *driver, 669 virDomainObj *vm, 670 virStorageSource *src, 671 virStorageSource *parent); 672 char *qemuDomainStorageAlias(const char *device, int depth); 673 674 const char * 675 qemuDomainDiskGetTopNodename(virDomainDiskDef *disk) 676 ATTRIBUTE_NONNULL(1); 677 678 int qemuDomainDiskGetBackendAlias(virDomainDiskDef *disk, 679 virQEMUCaps *qemuCaps, 680 char **backendAlias) 681 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) 682 ATTRIBUTE_NONNULL(3) G_GNUC_WARN_UNUSED_RESULT; 683 684 int qemuDomainStorageSourceChainAccessAllow(virQEMUDriver *driver, 685 virDomainObj *vm, 686 virStorageSource *src); 687 int qemuDomainStorageSourceChainAccessRevoke(virQEMUDriver *driver, 688 virDomainObj *vm, 689 virStorageSource *src); 690 691 void qemuDomainStorageSourceAccessRevoke(virQEMUDriver *driver, 692 virDomainObj *vm, 693 virStorageSource *elem); 694 int qemuDomainStorageSourceAccessAllow(virQEMUDriver *driver, 695 virDomainObj *vm, 696 virStorageSource *elem, 697 bool readonly, 698 bool newSource, 699 bool chainTop); 700 701 int qemuDomainPrepareStorageSourceBlockdev(virDomainDiskDef *disk, 702 virStorageSource *src, 703 qemuDomainObjPrivate *priv, 704 virQEMUDriverConfig *cfg); 705 706 int qemuDomainCleanupAdd(virDomainObj *vm, 707 qemuDomainCleanupCallback cb); 708 void qemuDomainCleanupRemove(virDomainObj *vm, 709 qemuDomainCleanupCallback cb); 710 void qemuDomainCleanupRun(virQEMUDriver *driver, 711 virDomainObj *vm); 712 713 void qemuDomainObjPrivateDataClear(qemuDomainObjPrivate *priv); 714 715 extern virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks; 716 extern virXMLNamespace virQEMUDriverDomainXMLNamespace; 717 extern virDomainDefParserConfig virQEMUDriverDomainDefParserConfig; 718 extern virDomainABIStability virQEMUDriverDomainABIStability; 719 extern virSaveCookieCallbacks virQEMUDriverDomainSaveCookie; 720 721 int qemuDomainUpdateDeviceList(virQEMUDriver *driver, 722 virDomainObj *vm, int asyncJob); 723 724 int qemuDomainUpdateMemoryDeviceInfo(virQEMUDriver *driver, 725 virDomainObj *vm, 726 int asyncJob); 727 728 bool qemuDomainDefCheckABIStability(virQEMUDriver *driver, 729 virQEMUCaps *qemuCaps, 730 virDomainDef *src, 731 virDomainDef *dst); 732 733 bool qemuDomainCheckABIStability(virQEMUDriver *driver, 734 virDomainObj *vm, 735 virDomainDef *dst); 736 737 bool qemuDomainAgentAvailable(virDomainObj *vm, 738 bool reportError); 739 740 bool qemuDomainDiskBlockJobIsActive(virDomainDiskDef *disk); 741 bool qemuDomainHasBlockjob(virDomainObj *vm, bool copy_only) 742 ATTRIBUTE_NONNULL(1); 743 744 int qemuDomainAlignMemorySizes(virDomainDef *def); 745 int qemuDomainMemoryDeviceAlignSize(virDomainDef *def, 746 virDomainMemoryDef *mem); 747 748 virDomainChrDef *qemuFindAgentConfig(virDomainDef *def); 749 750 /* You should normally avoid these functions and use the variant that 751 * doesn't have "Machine" in the name instead. */ 752 bool qemuDomainMachineIsARMVirt(const char *machine, 753 const virArch arch); 754 bool qemuDomainMachineIsPSeries(const char *machine, 755 const virArch arch); 756 bool qemuDomainMachineHasBuiltinIDE(const char *machine, 757 const virArch arch); 758 759 bool qemuDomainIsQ35(const virDomainDef *def); 760 bool qemuDomainIsI440FX(const virDomainDef *def); 761 bool qemuDomainIsS390CCW(const virDomainDef *def); 762 bool qemuDomainIsARMVirt(const virDomainDef *def); 763 bool qemuDomainIsRISCVVirt(const virDomainDef *def); 764 bool qemuDomainIsPSeries(const virDomainDef *def); 765 bool qemuDomainHasPCIRoot(const virDomainDef *def); 766 bool qemuDomainHasPCIeRoot(const virDomainDef *def); 767 bool qemuDomainHasBuiltinIDE(const virDomainDef *def); 768 bool qemuDomainHasBuiltinESP(const virDomainDef *def); 769 bool qemuDomainNeedsFDC(const virDomainDef *def); 770 bool qemuDomainSupportsPCI(virDomainDef *def, 771 virQEMUCaps *qemuCaps); 772 773 void qemuDomainUpdateCurrentMemorySize(virDomainObj *vm); 774 775 unsigned long long qemuDomainGetMemLockLimitBytes(virDomainDef *def, 776 bool forceVFIO); 777 int qemuDomainAdjustMaxMemLock(virDomainObj *vm, 778 bool forceVFIO); 779 int qemuDomainAdjustMaxMemLockHostdev(virDomainObj *vm, 780 virDomainHostdevDef *hostdev); 781 782 int qemuDomainDefValidateMemoryHotplug(const virDomainDef *def, 783 const virDomainMemoryDef *mem); 784 785 bool qemuDomainSupportsNewVcpuHotplug(virDomainObj *vm); 786 bool qemuDomainHasVcpuPids(virDomainObj *vm); 787 pid_t qemuDomainGetVcpuPid(virDomainObj *vm, unsigned int vcpuid); 788 int qemuDomainValidateVcpuInfo(virDomainObj *vm); 789 int qemuDomainRefreshVcpuInfo(virQEMUDriver *driver, 790 virDomainObj *vm, 791 int asyncJob, 792 bool state); 793 bool qemuDomainGetVcpuHalted(virDomainObj *vm, unsigned int vcpu); 794 int qemuDomainRefreshVcpuHalted(virQEMUDriver *driver, 795 virDomainObj *vm, 796 int asyncJob); 797 798 bool qemuDomainSupportsNicdev(virDomainDef *def, 799 virDomainNetDef *net); 800 801 bool qemuDomainNetSupportsMTU(virDomainNetType type); 802 803 int qemuDomainSetPrivatePaths(virQEMUDriver *driver, 804 virDomainObj *vm); 805 806 virDomainDiskDef *qemuDomainDiskByName(virDomainDef *def, const char *name); 807 808 char *qemuDomainGetMasterKeyFilePath(const char *libDir); 809 810 int qemuDomainMasterKeyReadFile(qemuDomainObjPrivate *priv); 811 812 int qemuDomainWriteMasterKeyFile(virQEMUDriver *driver, 813 virDomainObj *vm); 814 815 int qemuDomainMasterKeyCreate(virDomainObj *vm); 816 817 void qemuDomainMasterKeyRemove(qemuDomainObjPrivate *priv); 818 819 void qemuDomainSecretInfoFree(qemuDomainSecretInfo *secinfo) 820 ATTRIBUTE_NONNULL(1); 821 822 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDomainSecretInfo, qemuDomainSecretInfoFree); 823 824 void qemuDomainSecretInfoDestroy(qemuDomainSecretInfo *secinfo); 825 826 void qemuDomainSecretDiskDestroy(virDomainDiskDef *disk) 827 ATTRIBUTE_NONNULL(1); 828 829 bool qemuDomainStorageSourceHasAuth(virStorageSource *src) 830 ATTRIBUTE_NONNULL(1); 831 832 qemuDomainSecretInfo * 833 qemuDomainSecretInfoTLSNew(qemuDomainObjPrivate *priv, 834 const char *srcAlias, 835 const char *secretUUID); 836 837 void qemuDomainSecretHostdevDestroy(virDomainHostdevDef *disk) 838 ATTRIBUTE_NONNULL(1); 839 840 void qemuDomainSecretChardevDestroy(virDomainChrSourceDef *dev) 841 ATTRIBUTE_NONNULL(1); 842 843 int qemuDomainSecretChardevPrepare(virQEMUDriverConfig *cfg, 844 qemuDomainObjPrivate *priv, 845 const char *chrAlias, 846 virDomainChrSourceDef *dev) 847 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) 848 ATTRIBUTE_NONNULL(4); 849 850 void qemuDomainSecretDestroy(virDomainObj *vm) 851 ATTRIBUTE_NONNULL(1); 852 853 int qemuDomainSecretPrepare(virQEMUDriver *driver, 854 virDomainObj *vm) 855 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); 856 857 int qemuDomainDeviceDefValidateDisk(const virDomainDiskDef *disk, 858 virQEMUCaps *qemuCaps); 859 860 int qemuDomainDeviceDiskDefPostParse(virDomainDiskDef *disk, 861 unsigned int parseFlags); 862 863 int qemuDomainPrepareChannel(virDomainChrDef *chr, 864 const char *domainChannelTargetDir) 865 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); 866 867 void qemuDomainPrepareChardevSourceTLS(virDomainChrSourceDef *source, 868 virQEMUDriverConfig *cfg) 869 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); 870 871 void qemuDomainPrepareChardevSource(virDomainDef *def, 872 virQEMUDriverConfig *cfg) 873 ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2); 874 875 void qemuDomainPrepareShmemChardev(virDomainShmemDef *shmem) 876 ATTRIBUTE_NONNULL(1); 877 878 bool qemuDomainVcpuHotplugIsInOrder(virDomainDef *def) 879 ATTRIBUTE_NONNULL(1); 880 881 void qemuDomainVcpuPersistOrder(virDomainDef *def) 882 ATTRIBUTE_NONNULL(1); 883 884 int qemuDomainCheckMonitor(virQEMUDriver *driver, 885 virDomainObj *vm, 886 qemuDomainAsyncJob asyncJob); 887 888 bool qemuDomainSupportsVideoVga(const virDomainVideoDef *video, 889 virQEMUCaps *qemuCaps); 890 891 bool qemuDomainNeedsVFIO(const virDomainDef *def); 892 893 int qemuDomainGetHostdevPath(virDomainHostdevDef *dev, 894 char **path, 895 int *perms); 896 897 virDomainDiskDef *qemuDomainDiskLookupByNodename(virDomainDef *def, 898 virDomainBackupDef *backupdef, 899 const char *nodename, 900 virStorageSource **src); 901 902 char *qemuDomainDiskBackingStoreGetName(virDomainDiskDef *disk, 903 unsigned int idx); 904 905 virStorageSource *qemuDomainGetStorageSourceByDevstr(const char *devstr, 906 virDomainDef *def, 907 virDomainBackupDef *backupdef); 908 909 int 910 qemuDomainUpdateCPU(virDomainObj *vm, 911 virCPUDef *cpu, 912 virCPUDef **origCPU); 913 914 int 915 qemuDomainFixupCPUs(virDomainObj *vm, 916 virCPUDef **origCPU); 917 918 char * 919 qemuDomainGetMachineName(virDomainObj *vm); 920 921 void 922 qemuDomainObjPrivateXMLFormatAllowReboot(virBuffer *buf, 923 virTristateBool allowReboot); 924 925 int 926 qemuDomainObjPrivateXMLParseAllowReboot(xmlXPathContextPtr ctxt, 927 virTristateBool *allowReboot); 928 929 void 930 qemuDomainPrepareDiskSourceData(virDomainDiskDef *disk, 931 virStorageSource *src); 932 933 934 int 935 qemuDomainValidateStorageSource(virStorageSource *src, 936 virQEMUCaps *qemuCaps, 937 bool maskBlockdev); 938 939 940 int 941 qemuDomainPrepareDiskSource(virDomainDiskDef *disk, 942 qemuDomainObjPrivate *priv, 943 virQEMUDriverConfig *cfg); 944 945 int 946 qemuDomainDiskCachemodeFlags(int cachemode, 947 bool *writeback, 948 bool *direct, 949 bool *noflush); 950 951 int 952 qemuDomainPrepareHostdev(virDomainHostdevDef *hostdev, 953 qemuDomainObjPrivate *priv); 954 955 char * qemuDomainGetManagedPRSocketPath(qemuDomainObjPrivate *priv); 956 957 bool qemuDomainDefHasManagedPR(virDomainObj *vm); 958 959 unsigned int qemuDomainStorageIdNew(qemuDomainObjPrivate *priv); 960 void qemuDomainStorageIdReset(qemuDomainObjPrivate *priv); 961 962 virDomainEventResumedDetailType 963 qemuDomainRunningReasonToResumeEvent(virDomainRunningReason reason); 964 965 bool 966 qemuDomainDiskIsMissingLocalOptional(virDomainDiskDef *disk); 967 968 void 969 qemuDomainNVRAMPathFormat(virQEMUDriverConfig *cfg, 970 virDomainDef *def, 971 char **path); 972 973 void 974 qemuDomainNVRAMPathGenerate(virQEMUDriverConfig *cfg, 975 virDomainDef *def); 976 977 virDomainEventSuspendedDetailType 978 qemuDomainPausedReasonToSuspendedEvent(virDomainPausedReason reason); 979 980 int 981 qemuDomainValidateActualNetDef(const virDomainNetDef *net, 982 virQEMUCaps *qemuCaps); 983 984 int 985 qemuDomainSupportsCheckpointsBlockjobs(virDomainObj *vm) 986 G_GNUC_WARN_UNUSED_RESULT; 987 988 int 989 qemuDomainMakeCPUMigratable(virCPUDef *cpu); 990 991 int 992 qemuDomainInitializePflashStorageSource(virDomainObj *vm); 993 994 bool 995 qemuDomainDiskBlockJobIsSupported(virDomainObj *vm, 996 virDomainDiskDef *disk); 997 998 int 999 qemuDomainDefNumaCPUsRectify(virDomainDef *def, 1000 virQEMUCaps *qemuCaps); 1001 1002 void qemuDomainRemoveInactiveJob(virQEMUDriver *driver, 1003 virDomainObj *vm); 1004 1005 void qemuDomainRemoveInactiveJobLocked(virQEMUDriver *driver, 1006 virDomainObj *vm); 1007 1008 int virQEMUFileOpenAs(uid_t fallback_uid, 1009 gid_t fallback_gid, 1010 bool dynamicOwnership, 1011 const char *path, 1012 int oflags, 1013 bool *needUnlink); 1014 1015 int 1016 qemuDomainOpenFile(virQEMUDriverConfig *cfg, 1017 const virDomainDef *def, 1018 const char *path, 1019 int oflags, 1020 bool *needUnlink); 1021 1022 int 1023 qemuDomainFileWrapperFDClose(virDomainObj *vm, 1024 virFileWrapperFd *fd); 1025 1026 int 1027 qemuDomainInterfaceSetDefaultQDisc(virQEMUDriver *driver, 1028 virDomainNetDef *net); 1029 1030 int 1031 qemuDomainNamePathsCleanup(virQEMUDriverConfig *cfg, 1032 const char *name, 1033 bool bestEffort); 1034 1035 char * 1036 qemuDomainGetVHostUserFSSocketPath(qemuDomainObjPrivate *priv, 1037 const virDomainFSDef *fs); 1038