/** * qemuBlockJobEmitEvents: * * Emits the VIR_DOMAIN_EVENT_ID_BLOCK_JOB and VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 * for a block job. The former event is emitted only for local disks. */ static void qemuBlockJobEmitEvents(virQEMUDriverPtr driver, virDomainObjPtr vm, virDomainDiskDefPtr disk, virDomainBlockJobType type, virConnectDomainEventBlockJobStatus status) { virObjectEventPtr event = NULL; virObjectEventPtr event2 = NULL; /* don't emit events for internal jobs and states */ if (type >= VIR_DOMAIN_BLOCK_JOB_TYPE_LAST || status >= VIR_DOMAIN_BLOCK_JOB_LAST) return; if (virStorageSourceIsLocalStorage(disk->src) && !virStorageSourceIsEmpty(disk->src)) { event = virDomainEventBlockJobNewFromObj(vm, virDomainDiskGetSource(disk), type, status); virObjectEventStateQueue(driver->domainEventState, event); } event2 = virDomainEventBlockJob2NewFromObj(vm, disk->dst, type, status); virObjectEventStateQueue(driver->domainEventState, event2); }
static int virLXCProcessAutostartDomain(virDomainObjPtr vm, void *opaque) { const struct virLXCProcessAutostartData *data = opaque; int ret = 0; virObjectLock(vm); if (vm->autostart && !virDomainObjIsActive(vm)) { ret = virLXCProcessStart(data->conn, data->driver, vm, 0, NULL, false, VIR_DOMAIN_RUNNING_BOOTED); virDomainAuditStart(vm, "booted", ret >= 0); if (ret < 0) { virErrorPtr err = virGetLastError(); VIR_ERROR(_("Failed to autostart VM '%s': %s"), vm->def->name, err ? err->message : ""); } else { virObjectEventPtr event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); if (event) virObjectEventStateQueue(data->driver->domainEventState, event); } } virObjectUnlock(vm); return ret; }
static virDomainObjPtr lxcProcessAutoDestroy(virDomainObjPtr dom, virConnectPtr conn, void *opaque) { virLXCDriverPtr driver = opaque; virObjectEventPtr event = NULL; virLXCDomainObjPrivatePtr priv; VIR_DEBUG("driver=%p dom=%s conn=%p", driver, dom->def->name, conn); priv = dom->privateData; VIR_DEBUG("Killing domain"); virLXCProcessStop(driver, dom, VIR_DOMAIN_SHUTOFF_DESTROYED); virDomainAuditStop(dom, "destroyed"); event = virDomainEventLifecycleNewFromObj(dom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); priv->doneStopEvent = true; if (!dom->persistent) { virDomainObjListRemove(driver->domains, dom); dom = NULL; } if (event) virObjectEventStateQueue(driver->domainEventState, event); return dom; }
static int secretSetValue(virSecretPtr secret, const unsigned char *value, size_t value_size, unsigned int flags) { int ret = -1; virSecretObjPtr obj; virSecretDefPtr def; virObjectEventPtr event = NULL; virCheckFlags(0, -1); if (!(obj = secretObjFromSecret(secret))) goto cleanup; def = virSecretObjGetDef(obj); if (virSecretSetValueEnsureACL(secret->conn, def) < 0) goto cleanup; if (virSecretObjSetValue(obj, value, value_size) < 0) goto cleanup; event = virSecretEventValueChangedNew(def->uuid, def->usage_type, def->usage_id); ret = 0; cleanup: virSecretObjEndAPI(&obj); if (event) virObjectEventStateQueue(driver->secretEventState, event); return ret; }
static void virLXCProcessMonitorEOFNotify(virLXCMonitorPtr mon, virDomainObjPtr vm) { virLXCDriverPtr driver = lxc_driver; virObjectEventPtr event = NULL; virLXCDomainObjPrivatePtr priv; VIR_DEBUG("mon=%p vm=%p", mon, vm); virObjectLock(vm); priv = vm->privateData; virLXCProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN); if (!priv->wantReboot) { virLXCProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN); if (!priv->doneStopEvent) { event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, priv->stopReason); virDomainAuditStop(vm, "shutdown"); } else { VIR_DEBUG("Stop event has already been sent"); } if (!vm->persistent) { virDomainObjListRemove(driver->domains, vm); vm = NULL; } } else { int ret = virLXCProcessReboot(driver, vm); virDomainAuditStop(vm, "reboot"); virDomainAuditStart(vm, "reboot", ret == 0); if (ret == 0) { event = virDomainEventRebootNewFromObj(vm); } else { event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, priv->stopReason); if (!vm->persistent) { virDomainObjListRemove(driver->domains, vm); vm = NULL; } } } if (vm) virObjectUnlock(vm); if (event) { virObjectEventStateQueue(driver->domainEventState, event); } }
static int bhyveDomainUndefine(virDomainPtr domain) { bhyveConnPtr privconn = domain->conn->privateData; virObjectEventPtr event = NULL; virDomainObjPtr vm; int ret = -1; if (!(vm = bhyveDomObjFromDomain(domain))) goto cleanup; if (virDomainUndefineEnsureACL(domain->conn, vm->def) < 0) goto cleanup; if (!vm->persistent) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("Cannot undefine transient domain")); goto cleanup; } if (virDomainDeleteConfig(BHYVE_CONFIG_DIR, BHYVE_AUTOSTART_DIR, vm) < 0) goto cleanup; event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_UNDEFINED, VIR_DOMAIN_EVENT_UNDEFINED_REMOVED); if (virDomainObjIsActive(vm)) { vm->persistent = 0; } else { virDomainObjListRemove(privconn->domains, vm); vm = NULL; } ret = 0; cleanup: if (vm) virObjectUnlock(vm); if (event) virObjectEventStateQueue(privconn->domainEventState, event); return ret; }
static int bhyveDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) { bhyveConnPtr privconn = dom->conn->privateData; virDomainObjPtr vm; virObjectEventPtr event = NULL; unsigned int start_flags = 0; int ret = -1; virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, -1); if (flags & VIR_DOMAIN_START_AUTODESTROY) start_flags |= VIR_BHYVE_PROCESS_START_AUTODESTROY; if (!(vm = bhyveDomObjFromDomain(dom))) goto cleanup; if (virDomainCreateWithFlagsEnsureACL(dom->conn, vm->def) < 0) goto cleanup; if (virDomainObjIsActive(vm)) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("Domain is already running")); goto cleanup; } ret = virBhyveProcessStart(dom->conn, privconn, vm, VIR_DOMAIN_RUNNING_BOOTED, start_flags); if (ret == 0) event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); cleanup: if (vm) virObjectUnlock(vm); if (event) virObjectEventStateQueue(privconn->domainEventState, event); return ret; }
static int qemuSetupCpuCgroup(virDomainObjPtr vm) { qemuDomainObjPrivatePtr priv = vm->privateData; virObjectEventPtr event = NULL; virTypedParameterPtr eventParams = NULL; int eventNparams = 0; int eventMaxparams = 0; if (!virCgroupHasController(priv->cgroup, VIR_CGROUP_CONTROLLER_CPU)) { if (vm->def->cputune.sharesSpecified) { virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", _("CPU tuning is not available on this host")); return -1; } else { return 0; } } if (vm->def->cputune.sharesSpecified) { unsigned long long val; if (virCgroupSetCpuShares(priv->cgroup, vm->def->cputune.shares) < 0) return -1; if (virCgroupGetCpuShares(priv->cgroup, &val) < 0) return -1; if (vm->def->cputune.shares != val) { vm->def->cputune.shares = val; if (virTypedParamsAddULLong(&eventParams, &eventNparams, &eventMaxparams, VIR_DOMAIN_TUNABLE_CPU_CPU_SHARES, val) < 0) return -1; event = virDomainEventTunableNewFromObj(vm, eventParams, eventNparams); } virObjectEventStateQueue(priv->driver->domainEventState, event); } return 0; }
static int secretUndefine(virSecretPtr secret) { int ret = -1; virSecretObjPtr obj; virSecretDefPtr def; virObjectEventPtr event = NULL; if (!(obj = secretObjFromSecret(secret))) goto cleanup; def = virSecretObjGetDef(obj); if (virSecretUndefineEnsureACL(secret->conn, def) < 0) goto cleanup; if (virSecretObjDeleteConfig(obj) < 0) goto cleanup; event = virSecretEventLifecycleNew(def->uuid, def->usage_type, def->usage_id, VIR_SECRET_EVENT_UNDEFINED, 0); virSecretObjDeleteData(obj); virSecretObjListRemove(driver->secrets, obj); virObjectUnref(obj); obj = NULL; ret = 0; cleanup: virSecretObjEndAPI(&obj); if (event) virObjectEventStateQueue(driver->secretEventState, event); return ret; }
static int bhyveDomainDestroy(virDomainPtr dom) { bhyveConnPtr privconn = dom->conn->privateData; virDomainObjPtr vm; virObjectEventPtr event = NULL; int ret = -1; if (!(vm = bhyveDomObjFromDomain(dom))) goto cleanup; if (virDomainDestroyEnsureACL(dom->conn, vm->def) < 0) goto cleanup; if (!virDomainObjIsActive(vm)) { virReportError(VIR_ERR_OPERATION_INVALID, "%s", _("Domain is not running")); goto cleanup; } ret = virBhyveProcessStop(privconn, vm, VIR_DOMAIN_SHUTOFF_DESTROYED); event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); if (!vm->persistent) { virDomainObjListRemove(privconn->domains, vm); vm = NULL; } cleanup: if (vm) virObjectUnlock(vm); if (event) virObjectEventStateQueue(privconn->domainEventState, event); return ret; }
static virDomainPtr bhyveDomainCreateXML(virConnectPtr conn, const char *xml, unsigned int flags) { bhyveConnPtr privconn = conn->privateData; virDomainPtr dom = NULL; virDomainDefPtr def = NULL; virDomainObjPtr vm = NULL; virObjectEventPtr event = NULL; virCapsPtr caps = NULL; unsigned int start_flags = 0; virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, NULL); if (flags & VIR_DOMAIN_START_AUTODESTROY) start_flags |= VIR_BHYVE_PROCESS_START_AUTODESTROY; caps = bhyveDriverGetCapabilities(privconn); if (!caps) return NULL; if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt, 1 << VIR_DOMAIN_VIRT_BHYVE, VIR_DOMAIN_XML_INACTIVE)) == NULL) goto cleanup; if (virDomainCreateXMLEnsureACL(conn, def) < 0) goto cleanup; if (bhyveDomainAssignAddresses(def, NULL) < 0) goto cleanup; if (!(vm = virDomainObjListAdd(privconn->domains, def, privconn->xmlopt, VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE, NULL))) goto cleanup; def = NULL; if (virBhyveProcessStart(conn, privconn, vm, VIR_DOMAIN_RUNNING_BOOTED, start_flags) < 0) { /* If domain is not persistent, remove its data */ if (!vm->persistent) { virDomainObjListRemove(privconn->domains, vm); vm = NULL; } goto cleanup; } event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STARTED, VIR_DOMAIN_EVENT_STARTED_BOOTED); dom = virGetDomain(conn, vm->def->name, vm->def->uuid); if (dom) dom->id = vm->def->id; cleanup: virObjectUnref(caps); virDomainDefFree(def); if (vm) virObjectUnlock(vm); if (event) virObjectEventStateQueue(privconn->domainEventState, event); return dom; }
static virDomainPtr bhyveDomainDefineXML(virConnectPtr conn, const char *xml) { bhyveConnPtr privconn = conn->privateData; virDomainPtr dom = NULL; virDomainDefPtr def = NULL; virDomainDefPtr oldDef = NULL; virDomainObjPtr vm = NULL; virObjectEventPtr event = NULL; virCapsPtr caps = NULL; caps = bhyveDriverGetCapabilities(privconn); if (!caps) return NULL; if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt, 1 << VIR_DOMAIN_VIRT_BHYVE, VIR_DOMAIN_XML_INACTIVE)) == NULL) goto cleanup; if (virDomainDefineXMLEnsureACL(conn, def) < 0) goto cleanup; if (bhyveDomainAssignAddresses(def, NULL) < 0) goto cleanup; if (!(vm = virDomainObjListAdd(privconn->domains, def, privconn->xmlopt, 0, &oldDef))) goto cleanup; def = NULL; vm->persistent = 1; if (virDomainSaveConfig(BHYVE_CONFIG_DIR, vm->newDef ? vm->newDef : vm->def) < 0) { virDomainObjListRemove(privconn->domains, vm); vm = NULL; goto cleanup; } event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_DEFINED, !oldDef ? VIR_DOMAIN_EVENT_DEFINED_ADDED : VIR_DOMAIN_EVENT_DEFINED_UPDATED); dom = virGetDomain(conn, vm->def->name, vm->def->uuid); if (dom) dom->id = vm->def->id; cleanup: virObjectUnref(caps); virDomainDefFree(def); virDomainDefFree(oldDef); if (vm) virObjectUnlock(vm); if (event) virObjectEventStateQueue(privconn->domainEventState, event); return dom; }
static virSecretPtr secretDefineXML(virConnectPtr conn, const char *xml, unsigned int flags) { virSecretPtr ret = NULL; virSecretObjPtr obj = NULL; virSecretDefPtr objDef; virSecretDefPtr backup = NULL; virSecretDefPtr def; virObjectEventPtr event = NULL; virCheckFlags(0, NULL); if (!(def = virSecretDefParseString(xml))) return NULL; if (virSecretDefineXMLEnsureACL(conn, def) < 0) goto cleanup; if (!(obj = virSecretObjListAdd(driver->secrets, def, driver->configDir, &backup))) goto cleanup; VIR_STEAL_PTR(objDef, def); if (!objDef->isephemeral) { if (backup && backup->isephemeral) { if (virSecretObjSaveData(obj) < 0) goto restore_backup; } if (virSecretObjSaveConfig(obj) < 0) { if (backup && backup->isephemeral) { /* Undo the virSecretObjSaveData() above; ignore errors */ virSecretObjDeleteData(obj); } goto restore_backup; } } else if (backup && !backup->isephemeral) { if (virSecretObjDeleteConfig(obj) < 0) goto restore_backup; virSecretObjDeleteData(obj); } /* Saved successfully - drop old values */ virSecretDefFree(backup); event = virSecretEventLifecycleNew(objDef->uuid, objDef->usage_type, objDef->usage_id, VIR_SECRET_EVENT_DEFINED, 0); ret = virGetSecret(conn, objDef->uuid, objDef->usage_type, objDef->usage_id); goto cleanup; restore_backup: /* If we have a backup, then secret was defined before, so just restore * the backup; otherwise, this is a new secret, thus remove it. */ if (backup) { virSecretObjSetDef(obj, backup); VIR_STEAL_PTR(def, objDef); } else { virSecretObjListRemove(driver->secrets, obj); virObjectUnref(obj); obj = NULL; } cleanup: virSecretDefFree(def); virSecretObjEndAPI(&obj); if (event) virObjectEventStateQueue(driver->secretEventState, event); return ret; }