This introduces new API virDomainDestroyWithFlags to allow domain destroying with flags, as the existing API virDomainDestroy misses flags. The set of flags is defined in virDomainDestroyFlags enum, which is currently commented, because it is empty. Calling this API with no flags set (@flags == 0) is equivalent calling virDomainDestroy. --- include/libvirt/libvirt.h.in | 7 +++++ src/driver.h | 4 +++ src/libvirt.c | 52 ++++++++++++++++++++++++++++++++++++++++++ src/libvirt_public.syms | 1 + 4 files changed, 64 insertions(+), 0 deletions(-) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 6afd591..0a06684 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -913,6 +913,11 @@ virConnectPtr virDomainGetConnect (virDomainPtr domain); /* * Domain creation and destruction */ + +/* + * typedef enum { + * } virDomainDestroyFlags; + */ virDomainPtr virDomainCreateXML (virConnectPtr conn, const char *xmlDesc, unsigned int flags); @@ -929,6 +934,8 @@ int virDomainShutdown (virDomainPtr domain); int virDomainReboot (virDomainPtr domain, unsigned int flags); int virDomainDestroy (virDomainPtr domain); +int virDomainDestroyWithFlags(virDomainPtr domain, + unsigned int flags); int virDomainRef (virDomainPtr domain); int virDomainFree (virDomainPtr domain); diff --git a/src/driver.h b/src/driver.h index 4c4955f..f23a71b 100644 --- a/src/driver.h +++ b/src/driver.h @@ -124,6 +124,9 @@ typedef int unsigned int flags); typedef int (*virDrvDomainDestroy) (virDomainPtr domain); +typedef int + (*virDrvDomainDestroyWithFlags) (virDomainPtr domain, + unsigned int flags); typedef char * (*virDrvDomainGetOSType) (virDomainPtr domain); typedef unsigned long @@ -701,6 +704,7 @@ struct _virDriver { virDrvDomainShutdown domainShutdown; virDrvDomainReboot domainReboot; virDrvDomainDestroy domainDestroy; + virDrvDomainDestroyWithFlags domainDestroyWithFlags; virDrvDomainGetOSType domainGetOSType; virDrvDomainGetMaxMemory domainGetMaxMemory; virDrvDomainSetMaxMemory domainSetMaxMemory; diff --git a/src/libvirt.c b/src/libvirt.c index 16a9a02..44cb019 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -2078,6 +2078,58 @@ error: } /** + * virDomainDestroyWithFlags: + * @domain: a domain object + * @flags: an OR'ed set of virDomainDestroyFlags + * + * Destroy the domain object. The running instance is shutdown if not down + * already and all resources used by it are given back to the hypervisor. + * This does not free the associated virDomainPtr object. + * This function may require privileged access. + * + * Calling this function with no @flags set (equal zero) + * is equivalent calling virDomainDestroy. + * + * Returns 0 in case of success and -1 in case of failure. + */ +int +virDomainDestroyWithFlags(virDomainPtr domain, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + + conn = domain->conn; + if (conn->flags & VIR_CONNECT_RO) { + virLibDomainError(VIR_ERR_OPERATION_DENIED, __FUNCTION__); + goto error; + } + + if (conn->driver->domainDestroyWithFlags) { + int ret; + ret = conn->driver->domainDestroyWithFlags(domain, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(conn); + return -1; +} + +/** * virDomainFree: * @domain: a domain object * diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index 5cc480e..63ff0da 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -469,6 +469,7 @@ LIBVIRT_0.9.3 { LIBVIRT_0.9.4 { global: virDomainUndefineFlags; + virDomainDestroyWithFlags; } LIBVIRT_0.9.3; # .... define new API here using predicted next version number .... -- 1.7.5.rc3

于 2011年07月21日 19:13, Daniel P. Berrange 写道: For domainUndefine, the enum is named as virDomainUndefineFlagsValues, so that we can have the API named virDomainUndefineFlags. Osier

--- src/qemu/qemu_driver.c | 13 ++++++++++++- 1 files changed, 12 insertions(+), 1 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index e13b63b..ddadb08 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -1556,13 +1556,18 @@ cleanup: } -static int qemudDomainDestroy(virDomainPtr dom) { +static int +qemudDomainDestroyWithFlags(virDomainPtr dom, + unsigned int flags) +{ struct qemud_driver *driver = dom->conn->privateData; virDomainObjPtr vm; int ret = -1; virDomainEventPtr event = NULL; qemuDomainObjPrivatePtr priv; + virCheckFlags(0, -1); + qemuDriverLock(driver); vm = virDomainFindByUUID(&driver->domains, dom->uuid); if (!vm) { @@ -1620,6 +1625,11 @@ cleanup: return ret; } +static int +qemudDomainDestroy(virDomainPtr dom) +{ + return qemudDomainDestroyWithFlags(dom, 0); +} static char *qemudDomainGetOSType(virDomainPtr dom) { struct qemud_driver *driver = dom->conn->privateData; @@ -8621,6 +8631,7 @@ static virDriver qemuDriver = { .domainShutdown = qemuDomainShutdown, /* 0.2.0 */ .domainReboot = qemuDomainReboot, /* 0.9.3 */ .domainDestroy = qemudDomainDestroy, /* 0.2.0 */ + .domainDestroyWithFlags = qemudDomainDestroyWithFlags, /* 0.9.4 */ .domainGetOSType = qemudDomainGetOSType, /* 0.2.2 */ .domainGetMaxMemory = qemudDomainGetMaxMemory, /* 0.4.2 */ .domainSetMaxMemory = qemudDomainSetMaxMemory, /* 0.4.2 */ -- 1.7.5.rc3

--- src/esx/esx_driver.c | 12 +++++++++++- 1 files changed, 11 insertions(+), 1 deletions(-) diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index 5ed6a38..f98c579 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -1937,7 +1937,8 @@ esxDomainReboot(virDomainPtr domain, unsigned int flags) static int -esxDomainDestroy(virDomainPtr domain) +esxDomainDestroyWithFlags(virDomainPtr domain, + unsigned int flags) { int result = -1; esxPrivate *priv = domain->conn->privateData; @@ -1949,6 +1950,8 @@ esxDomainDestroy(virDomainPtr domain) esxVI_TaskInfoState taskInfoState; char *taskInfoErrorMessage = NULL; + virCheckFlags(0, -1); + if (priv->vCenter != NULL) { ctx = priv->vCenter; } else { @@ -2001,6 +2004,12 @@ esxDomainDestroy(virDomainPtr domain) } +static int +esxDomainDestroy(virDomainPtr dom) +{ + return esxDomainDestroyWithFlags(dom, 0); +} + static char * esxDomainGetOSType(virDomainPtr domain ATTRIBUTE_UNUSED) @@ -4734,6 +4743,7 @@ static virDriver esxDriver = { .domainShutdown = esxDomainShutdown, /* 0.7.0 */ .domainReboot = esxDomainReboot, /* 0.7.0 */ .domainDestroy = esxDomainDestroy, /* 0.7.0 */ + .domainDestroyWithFlags = esxDomainDestroyWithFlags, /* 0.9.4 */ .domainGetOSType = esxDomainGetOSType, /* 0.7.0 */ .domainGetMaxMemory = esxDomainGetMaxMemory, /* 0.7.0 */ .domainSetMaxMemory = esxDomainSetMaxMemory, /* 0.7.0 */ -- 1.7.5.rc3

--- src/lxc/lxc_driver.c | 23 +++++++++++++++++++++-- 1 files changed, 21 insertions(+), 2 deletions(-) diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index afac879..7fc9921 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -1934,20 +1934,25 @@ static void lxcDomainEventQueue(lxc_driver_t *driver, } /** - * lxcDomainDestroy: + * lxcDomainDestroyWithFlags: * @dom: pointer to domain to destroy + * @flags: an OR'ed set of virDomainDestroyFlags * * Sends SIGKILL to container root process to terminate the container * * Returns 0 on success or -1 in case of error */ -static int lxcDomainDestroy(virDomainPtr dom) +static int +lxcDomainDestroyWithFlags(virDomainPtr dom, + unsigned int flags) { lxc_driver_t *driver = dom->conn->privateData; virDomainObjPtr vm; virDomainEventPtr event = NULL; int ret = -1; + virCheckFlags(0, -1); + lxcDriverLock(driver); vm = virDomainFindByUUID(&driver->domains, dom->uuid); if (!vm) { @@ -1983,6 +1988,20 @@ cleanup: return ret; } +/** + * lxcDomainDestroy: + * @dom: pointer to domain to destroy + * + * Sends SIGKILL to container root process to terminate the container + * + * Returns 0 on success or -1 in case of error + */ +static int +lxcDomainDestroy(virDomainPtr dom) +{ + return lxcDomainDestroyWithFlags(dom, 0); +} + static int lxcCheckNetNsSupport(void) { const char *argv[] = {"ip", "link", "set", "lo", "netns", "-1", NULL}; -- 1.7.5.rc3

--- src/phyp/phyp_driver.c | 12 +++++++++++- 1 files changed, 11 insertions(+), 1 deletions(-) diff --git a/src/phyp/phyp_driver.c b/src/phyp/phyp_driver.c index 2489063..eea229a 100644 --- a/src/phyp/phyp_driver.c +++ b/src/phyp/phyp_driver.c @@ -3497,7 +3497,8 @@ phypDomainGetState(virDomainPtr dom, } static int -phypDomainDestroy(virDomainPtr dom) +phypDomainDestroyWithFlags(virDomainPtr dom, + unsigned int flags) { int result = -1; ConnectionData *connection_data = dom->conn->networkPrivateData; @@ -3509,6 +3510,8 @@ phypDomainDestroy(virDomainPtr dom) char *ret = NULL; virBuffer buf = VIR_BUFFER_INITIALIZER; + virCheckFlags(0, -1); + virBufferAddLit(&buf, "rmsyscfg"); if (system_type == HMC) virBufferAsprintf(&buf, " -m %s", managed_system); @@ -3531,6 +3534,12 @@ cleanup: } static int +phypDomainDestroy(virDomainPtr dom) +{ + return phypDomainDestroyWithFlags(dom, 0); +} + +static int phypBuildLpar(virConnectPtr conn, virDomainDefPtr def) { int result = -1; @@ -3763,6 +3772,7 @@ static virDriver phypDriver = { .domainShutdown = phypDomainShutdown, /* 0.7.0 */ .domainReboot = phypDomainReboot, /* 0.9.1 */ .domainDestroy = phypDomainDestroy, /* 0.7.3 */ + .domainDestroyWithFlags = phypDomainDestroyWithFlags, /* 0.9.4 */ .domainGetInfo = phypDomainGetInfo, /* 0.7.0 */ .domainGetState = phypDomainGetState, /* 0.9.2 */ .domainSetVcpus = phypDomainSetCPU, /* 0.7.3 */ -- 1.7.5.rc3

--- src/vbox/vbox_tmpl.c | 14 +++++++++++++- 1 files changed, 13 insertions(+), 1 deletions(-) diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 53bac79..19fdaef 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -1689,7 +1689,10 @@ cleanup: return ret; } -static int vboxDomainDestroy(virDomainPtr dom) { +static int +vboxDomainDestroyWithFlags(virDomainPtr dom, + unsigned int flags) +{ VBOX_OBJECT_CHECK(dom->conn, int, -1); IMachine *machine = NULL; vboxIID iid = VBOX_IID_INITIALIZER; @@ -1698,6 +1701,8 @@ static int vboxDomainDestroy(virDomainPtr dom) { PRBool isAccessible = PR_FALSE; nsresult rc; + virCheckFlags(0, -1); + vboxIIDFromUUID(&iid, dom->uuid); rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine); if (NS_FAILED(rc)) { @@ -1746,6 +1751,12 @@ cleanup: return ret; } +static int +vboxDomainDestroy(virDomainPtr dom) +{ + return vboxDomainDestroyWithFlags(dom, 0); +} + static char *vboxDomainGetOSType(virDomainPtr dom ATTRIBUTE_UNUSED) { /* Returning "hvm" always as suggested on list, cause * this functions seems to be badly named and it @@ -8774,6 +8785,7 @@ virDriver NAME(Driver) = { .domainShutdown = vboxDomainShutdown, /* 0.6.3 */ .domainReboot = vboxDomainReboot, /* 0.6.3 */ .domainDestroy = vboxDomainDestroy, /* 0.6.3 */ + .domainDestroyWithFlags = vboxDomainDestroyWithFlags, /* 0.9.4 */ .domainGetOSType = vboxDomainGetOSType, /* 0.6.3 */ .domainSetMemory = vboxDomainSetMemory, /* 0.6.3 */ .domainGetInfo = vboxDomainGetInfo, /* 0.6.3 */ -- 1.7.5.rc3

--- src/xen/xen_driver.c | 28 ++++++++++++++++++++++++++++ src/xen/xen_driver.h | 1 + src/xen/xen_hypervisor.c | 24 ++++++++++++++++++++++-- src/xen/xen_hypervisor.h | 3 +++ src/xen/xen_inotify.c | 1 + src/xen/xend_internal.c | 24 ++++++++++++++++++++++-- src/xen/xm_internal.c | 1 + src/xen/xs_internal.c | 1 + 8 files changed, 79 insertions(+), 4 deletions(-) diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c index 3b5df46..ce29fc4 100644 --- a/src/xen/xen_driver.c +++ b/src/xen/xen_driver.c @@ -925,6 +925,33 @@ xenUnifiedDomainDestroy (virDomainPtr dom) return -1; } +static int +xenUnifiedDomainDestroyWithFlags(virDomainPtr dom, + unsigned int flags) +{ + GET_PRIVATE(dom->conn); + int i; + + virCheckFlags(0, -1); + + /* Try non-hypervisor methods first, then hypervisor direct method + * as a last resort. + */ + for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i) + if (i != XEN_UNIFIED_HYPERVISOR_OFFSET && + priv->opened[i] && + drivers[i]->domainDestroyWithFlags && + drivers[i]->domainDestroyWithFlags(dom) == 0) + return 0; + + if (priv->opened[XEN_UNIFIED_HYPERVISOR_OFFSET] && + drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainDestroyWithFlags&& + drivers[XEN_UNIFIED_HYPERVISOR_OFFSET]->domainDestroyWithFlags(dom) == 0) + return 0; + + return -1; +} + static char * xenUnifiedDomainGetOSType (virDomainPtr dom) { @@ -2205,6 +2232,7 @@ static virDriver xenUnifiedDriver = { .domainShutdown = xenUnifiedDomainShutdown, /* 0.0.3 */ .domainReboot = xenUnifiedDomainReboot, /* 0.1.0 */ .domainDestroy = xenUnifiedDomainDestroy, /* 0.0.3 */ + .domainDestroyWithFlags = xenUnifiedDomainDestroyWithFlags, /* 0.9.4 */ .domainGetOSType = xenUnifiedDomainGetOSType, /* 0.0.3 */ .domainGetMaxMemory = xenUnifiedDomainGetMaxMemory, /* 0.0.3 */ .domainSetMaxMemory = xenUnifiedDomainSetMaxMemory, /* 0.0.3 */ diff --git a/src/xen/xen_driver.h b/src/xen/xen_driver.h index a6fe475..1f9c17a 100644 --- a/src/xen/xen_driver.h +++ b/src/xen/xen_driver.h @@ -95,6 +95,7 @@ struct xenUnifiedDriver { virDrvDomainShutdown domainShutdown; virDrvDomainReboot domainReboot; virDrvDomainDestroy domainDestroy; + virDrvDomainDestroyWithFlags domainDestroyWithFlags; virDrvDomainGetOSType domainGetOSType; virDrvDomainGetMaxMemory domainGetMaxMemory; virDrvDomainSetMaxMemory domainSetMaxMemory; diff --git a/src/xen/xen_hypervisor.c b/src/xen/xen_hypervisor.c index 543dfb1..e9920d2 100644 --- a/src/xen/xen_hypervisor.c +++ b/src/xen/xen_hypervisor.c @@ -816,6 +816,7 @@ struct xenUnifiedDriver xenHypervisorDriver = { NULL, /* domainShutdown */ NULL, /* domainReboot */ xenHypervisorDestroyDomain, /* domainDestroy */ + xenHypervisorDestroyDomainWithFlags, /* domainDestroyWithFlags */ xenHypervisorDomainGetOSType, /* domainGetOSType */ xenHypervisorGetMaxMemory, /* domainGetMaxMemory */ xenHypervisorSetMaxMemory, /* domainSetMaxMemory */ @@ -3433,19 +3434,26 @@ xenHypervisorResumeDomain(virDomainPtr domain) } /** - * xenHypervisorDestroyDomain: + * xenHypervisorDestroyDomainWithFlags: * @domain: pointer to the domain block + * @flags: an OR'ed set of virDomainDestroyFlags * * Do an hypervisor call to destroy the given domain * + * Calling this function with no @flags set (equal zero + * is equivalent calling xenHypervisorDestroyDomain. + * * Returns 0 in case of success, -1 in case of error. */ int -xenHypervisorDestroyDomain(virDomainPtr domain) +xenHypervisorDestroyDomainWithFlags(virDomainPtr domain, + unsigned int flags) { int ret; xenUnifiedPrivatePtr priv; + virCheckFlags(0, -1); + if (domain->conn == NULL) return -1; @@ -3460,6 +3468,18 @@ xenHypervisorDestroyDomain(virDomainPtr domain) } /** + * xenHypervisorDestroyDomain: + * @domain: pointer to the domain block + * + * See xenHypervisorDestroyDomainWithFlags + */ +int +xenHypervisorDestroyDomain(virDomainPtr domain) +{ + return xenHypervisorDestroyDomainWithFlags(domain, 0); +} + +/** * xenHypervisorSetMaxMemory: * @domain: pointer to the domain block * @memory: the max memory size in kilobytes. diff --git a/src/xen/xen_hypervisor.h b/src/xen/xen_hypervisor.h index d522d5b..d838ae8 100644 --- a/src/xen/xen_hypervisor.h +++ b/src/xen/xen_hypervisor.h @@ -59,6 +59,9 @@ int xenHypervisorGetMaxVcpus (virConnectPtr conn, const char *type); int xenHypervisorDestroyDomain (virDomainPtr domain) ATTRIBUTE_NONNULL (1); +int xenHypervisorDestroyDomainWithFlags(virDomainPtr domain, + unsigned int flags) + ATTRIBUTE_NONNULL (1); int xenHypervisorResumeDomain (virDomainPtr domain) ATTRIBUTE_NONNULL (1); int xenHypervisorPauseDomain (virDomainPtr domain) diff --git a/src/xen/xen_inotify.c b/src/xen/xen_inotify.c index 241dbc7..98f3081 100644 --- a/src/xen/xen_inotify.c +++ b/src/xen/xen_inotify.c @@ -63,6 +63,7 @@ struct xenUnifiedDriver xenInotifyDriver = { NULL, /* domainShutdown */ NULL, /* domainReboot */ NULL, /* domainDestroy */ + NULL, /* domainDestroyWithFlags */ NULL, /* domainGetOSType */ NULL, /* domainGetMaxMemory */ NULL, /* domainSetMaxMemory */ diff --git a/src/xen/xend_internal.c b/src/xen/xend_internal.c index dec8484..b295035 100644 --- a/src/xen/xend_internal.c +++ b/src/xen/xend_internal.c @@ -1509,8 +1509,9 @@ xenDaemonDomainReboot(virDomainPtr domain, unsigned int flags) } /** - * xenDaemonDomainDestroy: + * xenDaemonDomainDestroyWithFlags: * @domain: pointer to the Domain block + * @flags: an OR'ed set of virDomainDestroyFlags * * Abruptly halt the domain, the OS is not properly shutdown and the * resources allocated for the domain are immediately freed, mounted @@ -1519,11 +1520,17 @@ xenDaemonDomainReboot(virDomainPtr domain, unsigned int flags) * dying and will go away completely once all of the resources have been * unmapped (usually from the backend devices). * + * Calling this function with no @flags set (equal zero) + * is equivalent calling xenDaemonDomainDestroy. + * * Returns 0 in case of success, -1 (with errno) in case of error. */ int -xenDaemonDomainDestroy(virDomainPtr domain) +xenDaemonDomainDestroyWithFlags(virDomainPtr domain, + unsigned int flags) { + virCheckFlags(0, -1); + if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL)) { virXendError(VIR_ERR_INVALID_ARG, __FUNCTION__); return(-1); @@ -1539,6 +1546,18 @@ xenDaemonDomainDestroy(virDomainPtr domain) } /** + * xenDaemonDomainDestroy: + * @domain: pointer to the Domain block + * + * See xenDaemonDomainDestroyWithFlags + */ +int +xenDaemonDomainDestroy(virDomainPtr dom) +{ + return xenDaemonDomainDestroyWithFlags(dom, 0); +} + +/** * xenDaemonDomainGetOSType: * @domain: a domain object * @@ -3941,6 +3960,7 @@ struct xenUnifiedDriver xenDaemonDriver = { xenDaemonDomainShutdown, /* domainShutdown */ xenDaemonDomainReboot, /* domainReboot */ xenDaemonDomainDestroy, /* domainDestroy */ + xenDaemonDomainDestroyWithFlags, /* domainDestroyWithFlags */ xenDaemonDomainGetOSType, /* domainGetOSType */ xenDaemonDomainGetMaxMemory, /* domainGetMaxMemory */ xenDaemonDomainSetMaxMemory, /* domainSetMaxMemory */ diff --git a/src/xen/xm_internal.c b/src/xen/xm_internal.c index 6ec295e..b907ade 100644 --- a/src/xen/xm_internal.c +++ b/src/xen/xm_internal.c @@ -95,6 +95,7 @@ struct xenUnifiedDriver xenXMDriver = { NULL, /* domainShutdown */ NULL, /* domainReboot */ NULL, /* domainDestroy */ + NULL, /* domainDestroyWithFlags */ NULL, /* domainGetOSType */ xenXMDomainGetMaxMemory, /* domainGetMaxMemory */ xenXMDomainSetMaxMemory, /* domainSetMaxMemory */ diff --git a/src/xen/xs_internal.c b/src/xen/xs_internal.c index f62d716..ddd51fa 100644 --- a/src/xen/xs_internal.c +++ b/src/xen/xs_internal.c @@ -56,6 +56,7 @@ struct xenUnifiedDriver xenStoreDriver = { xenStoreDomainShutdown, /* domainShutdown */ xenStoreDomainReboot, /* domainReboot */ NULL, /* domainDestroy */ + NULL, /* domainDestroyWithFlags */ xenStoreDomainGetOSType, /* domainGetOSType */ xenStoreDomainGetMaxMemory, /* domainGetMaxMemory */ NULL, /* domainSetMaxMemory */ -- 1.7.5.rc3