On 05/04/2011 08:45 AM, Jiri Denemark wrote: Definitely add the unsigned int flags argument. I'm not sure yet whether we want to pass a struct instead of two int* arguments; if nothing else, a flag could let us treat the argument as a union of different structs, and return a different struct of information according to which flag was requested. 0.9.2 -- Eric Blake eblake(a)redhat.com +1-801-349-2682 Libvirt virtualization library http://libvirt.org

--- src/driver.h | 5 +++++ src/esx/esx_driver.c | 1 + src/libxl/libxl_driver.c | 1 + src/lxc/lxc_driver.c | 1 + src/openvz/openvz_driver.c | 1 + src/phyp/phyp_driver.c | 1 + src/qemu/qemu_driver.c | 1 + src/remote/remote_driver.c | 1 + src/test/test_driver.c | 1 + src/uml/uml_driver.c | 1 + src/vbox/vbox_tmpl.c | 1 + src/vmware/vmware_driver.c | 1 + src/xen/xen_driver.c | 1 + src/xen/xen_driver.h | 1 + src/xen/xen_hypervisor.c | 1 + src/xen/xen_inotify.c | 1 + src/xen/xend_internal.c | 1 + src/xen/xm_internal.c | 1 + src/xen/xs_internal.c | 1 + src/xenapi/xenapi_driver.c | 1 + 20 files changed, 24 insertions(+), 0 deletions(-) diff --git a/src/driver.h b/src/driver.h index a8b79e6..d9898d4 100644 --- a/src/driver.h +++ b/src/driver.h @@ -166,6 +166,10 @@ typedef int (*virDrvDomainGetInfo) (virDomainPtr domain, virDomainInfoPtr info); typedef int + (*virDrvDomainGetState) (virDomainPtr domain, + int *state, + int *reason); +typedef int (*virDrvDomainSave) (virDomainPtr domain, const char *to); typedef int @@ -563,6 +567,7 @@ struct _virDriver { virDrvDomainSetBlkioParameters domainSetBlkioParameters; virDrvDomainGetBlkioParameters domainGetBlkioParameters; virDrvDomainGetInfo domainGetInfo; + virDrvDomainGetState domainGetState; virDrvDomainSave domainSave; virDrvDomainRestore domainRestore; virDrvDomainCoreDump domainCoreDump; diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index 1f8f90b..543ebe6 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -4596,6 +4596,7 @@ static virDriver esxDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ esxDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c index 247d78e..db6f99c 100644 --- a/src/libxl/libxl_driver.c +++ b/src/libxl/libxl_driver.c @@ -2672,6 +2672,7 @@ static virDriver libxlDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ libxlDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index e905302..bc96ed4 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -2830,6 +2830,7 @@ static virDriver lxcDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ lxcDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c index 4af28e9..268e752 100644 --- a/src/openvz/openvz_driver.c +++ b/src/openvz/openvz_driver.c @@ -1591,6 +1591,7 @@ static virDriver openvzDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ openvzDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/phyp/phyp_driver.c b/src/phyp/phyp_driver.c index ebd4a8a..fb365ba 100644 --- a/src/phyp/phyp_driver.c +++ b/src/phyp/phyp_driver.c @@ -3752,6 +3752,7 @@ static virDriver phypDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ phypDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 7132837..549cb2f 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -7140,6 +7140,7 @@ static virDriver qemuDriver = { qemuDomainSetBlkioParameters, /* domainSetBlkioParameters */ qemuDomainGetBlkioParameters, /* domainGetBlkioParameters */ qemudDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ qemudDomainSave, /* domainSave */ qemuDomainRestore, /* domainRestore */ qemudDomainCoreDump, /* domainCoreDump */ diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index e30780c..9796bb5 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -11222,6 +11222,7 @@ static virDriver remote_driver = { remoteDomainSetBlkioParameters, /* domainSetBlkioParameters */ remoteDomainGetBlkioParameters, /* domainGetBlkioParameters */ remoteDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ remoteDomainSave, /* domainSave */ remoteDomainRestore, /* domainRestore */ remoteDomainCoreDump, /* domainCoreDump */ diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 0978214..6f4ae75 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -5371,6 +5371,7 @@ static virDriver testDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ testGetDomainInfo, /* domainGetInfo */ + NULL, /* domainGetState */ testDomainSave, /* domainSave */ testDomainRestore, /* domainRestore */ testDomainCoreDump, /* domainCoreDump */ diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c index 33849a0..6852a16 100644 --- a/src/uml/uml_driver.c +++ b/src/uml/uml_driver.c @@ -2177,6 +2177,7 @@ static virDriver umlDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ umlDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 8241d34..d4a8924 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -8566,6 +8566,7 @@ virDriver NAME(Driver) = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ vboxDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ vboxDomainSave, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/vmware/vmware_driver.c b/src/vmware/vmware_driver.c index bbfb1a4..c6c92c6 100644 --- a/src/vmware/vmware_driver.c +++ b/src/vmware/vmware_driver.c @@ -931,6 +931,7 @@ static virDriver vmwareDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ vmwareDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c index dd94fbc..1646828 100644 --- a/src/xen/xen_driver.c +++ b/src/xen/xen_driver.c @@ -2132,6 +2132,7 @@ static virDriver xenUnifiedDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ xenUnifiedDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ xenUnifiedDomainSave, /* domainSave */ xenUnifiedDomainRestore, /* domainRestore */ xenUnifiedDomainCoreDump, /* domainCoreDump */ diff --git a/src/xen/xen_driver.h b/src/xen/xen_driver.h index 58b8561..6619494 100644 --- a/src/xen/xen_driver.h +++ b/src/xen/xen_driver.h @@ -90,6 +90,7 @@ struct xenUnifiedDriver { virDrvDomainSetMaxMemory domainSetMaxMemory; virDrvDomainSetMemory domainSetMemory; virDrvDomainGetInfo domainGetInfo; + virDrvDomainGetState domainGetState; virDrvDomainSave domainSave; virDrvDomainRestore domainRestore; virDrvDomainCoreDump domainCoreDump; diff --git a/src/xen/xen_hypervisor.c b/src/xen/xen_hypervisor.c index 9a5b41d..f5218bc 100644 --- a/src/xen/xen_hypervisor.c +++ b/src/xen/xen_hypervisor.c @@ -821,6 +821,7 @@ struct xenUnifiedDriver xenHypervisorDriver = { xenHypervisorSetMaxMemory, /* domainSetMaxMemory */ NULL, /* domainSetMemory */ xenHypervisorGetDomainInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/xen/xen_inotify.c b/src/xen/xen_inotify.c index 9dde72c..a2661a4 100644 --- a/src/xen/xen_inotify.c +++ b/src/xen/xen_inotify.c @@ -69,6 +69,7 @@ struct xenUnifiedDriver xenInotifyDriver = { NULL, /* domainSetMaxMemory */ NULL, /* domainSetMemory */ NULL, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/xen/xend_internal.c b/src/xen/xend_internal.c index b608a43..1fbb8e6 100644 --- a/src/xen/xend_internal.c +++ b/src/xen/xend_internal.c @@ -3861,6 +3861,7 @@ struct xenUnifiedDriver xenDaemonDriver = { xenDaemonDomainSetMaxMemory, /* domainSetMaxMemory */ xenDaemonDomainSetMemory, /* domainMaxMemory */ xenDaemonDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ xenDaemonDomainSave, /* domainSave */ xenDaemonDomainRestore, /* domainRestore */ xenDaemonDomainCoreDump, /* domainCoreDump */ diff --git a/src/xen/xm_internal.c b/src/xen/xm_internal.c index f9f52b5..06334a4 100644 --- a/src/xen/xm_internal.c +++ b/src/xen/xm_internal.c @@ -100,6 +100,7 @@ struct xenUnifiedDriver xenXMDriver = { xenXMDomainSetMaxMemory, /* domainSetMaxMemory */ xenXMDomainSetMemory, /* domainMaxMemory */ xenXMDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/xen/xs_internal.c b/src/xen/xs_internal.c index c318f6c..127161c 100644 --- a/src/xen/xs_internal.c +++ b/src/xen/xs_internal.c @@ -62,6 +62,7 @@ struct xenUnifiedDriver xenStoreDriver = { NULL, /* domainSetMaxMemory */ xenStoreDomainSetMemory, /* domainSetMemory */ xenStoreGetDomainInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ diff --git a/src/xenapi/xenapi_driver.c b/src/xenapi/xenapi_driver.c index 3fbdcc6..83417df 100644 --- a/src/xenapi/xenapi_driver.c +++ b/src/xenapi/xenapi_driver.c @@ -1813,6 +1813,7 @@ static virDriver xenapiDriver = { NULL, /* domainSetBlkioParameters */ NULL, /* domainGetBlkioParameters */ xenapiDomainGetInfo, /* domainGetInfo */ + NULL, /* domainGetState */ NULL, /* domainSave */ NULL, /* domainRestore */ NULL, /* domainCoreDump */ -- 1.7.5.rc3

--- src/libvirt.c | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 47 insertions(+), 0 deletions(-) diff --git a/src/libvirt.c b/src/libvirt.c index e74e977..5cd20ce 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -3173,6 +3173,53 @@ error: } /** + * virDomainGetState: + * @domain: a domain object + * @state: returned state of the domain (one of virDomainState) + * @reason: returned reason which led to @state (one of virDomain*Reason + * corresponding to the current state); it is allowed to be NULL + * + * Extract domain state. Each state can be accompanied with a reason (if known) + * which led to the state. + * + * Returns 0 in case of success and -1 in case of failure. + */ +int +virDomainGetState(virDomainPtr domain, int *state, int *reason) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain, "state=%p, reason=%p", state, reason); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + if (!state) { + virLibDomainError(VIR_ERR_INVALID_ARG, __FUNCTION__); + goto error; + } + + conn = domain->conn; + if (conn->driver->domainGetState) { + int ret; + ret = conn->driver->domainGetState(domain, state, reason); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return -1; +} + +/** * virDomainGetXMLDesc: * @domain: a domain object * @flags: an OR'ed set of virDomainXMLFlags -- 1.7.5.rc3

--- daemon/remote.c | 33 +++++++++++++++++++++++++++++++++ daemon/remote_dispatch_prototypes.h | 8 ++++++++ daemon/remote_dispatch_table.h | 5 +++++ src/remote/remote_protocol.c | 20 ++++++++++++++++++++ src/remote/remote_protocol.h | 16 ++++++++++++++++ src/remote/remote_protocol.x | 12 +++++++++++- src/remote_protocol-structs | 7 +++++++ 7 files changed, 100 insertions(+), 1 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index eedbc77..0136318 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -8738,6 +8738,39 @@ cleanup: return rv; } +static int +remoteDispatchDomainGetState(struct qemud_server *server ATTRIBUTE_UNUSED, + struct qemud_client *client ATTRIBUTE_UNUSED, + virConnectPtr conn, + remote_message_header *hdr ATTRIBUTE_UNUSED, + remote_error *rerr, + remote_domain_get_state_args *args, + remote_domain_get_state_ret *ret) +{ + virDomainPtr dom = NULL; + int rv = -1; + + if (!conn) { + virNetError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(dom = get_nonnull_domain(conn, args->dom))) + goto cleanup; + + if (virDomainGetState(dom, &ret->state, &ret->reason) < 0) + goto cleanup; + + rv = 0; + +cleanup: + if (rv < 0) + remoteDispatchError(rerr); + if (dom) + virDomainFree(dom); + return rv; +} + /*----- Helpers. -----*/ diff --git a/daemon/remote_dispatch_prototypes.h b/daemon/remote_dispatch_prototypes.h index cf2f38c..73d810d 100644 --- a/daemon/remote_dispatch_prototypes.h +++ b/daemon/remote_dispatch_prototypes.h @@ -306,6 +306,14 @@ static int remoteDispatchDomainGetSecurityLabel( remote_error *rerr, remote_domain_get_security_label_args *args, remote_domain_get_security_label_ret *ret); +static int remoteDispatchDomainGetState( + struct qemud_server *server, + struct qemud_client *client, + virConnectPtr conn, + remote_message_header *hdr, + remote_error *rerr, + remote_domain_get_state_args *args, + remote_domain_get_state_ret *ret); static int remoteDispatchDomainGetVcpus( struct qemud_server *server, struct qemud_client *client, diff --git a/daemon/remote_dispatch_table.h b/daemon/remote_dispatch_table.h index b39f7c2..07ffd5e 100644 --- a/daemon/remote_dispatch_table.h +++ b/daemon/remote_dispatch_table.h @@ -1052,3 +1052,8 @@ .args_filter = (xdrproc_t) xdr_remote_storage_vol_download_args, .ret_filter = (xdrproc_t) xdr_void, }, +{ /* DomainGetState => 210 */ + .fn = (dispatch_fn) remoteDispatchDomainGetState, + .args_filter = (xdrproc_t) xdr_remote_domain_get_state_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_get_state_ret, +}, diff --git a/src/remote/remote_protocol.c b/src/remote/remote_protocol.c index 5604371..eb68c79 100644 --- a/src/remote/remote_protocol.c +++ b/src/remote/remote_protocol.c @@ -3902,6 +3902,26 @@ xdr_remote_storage_vol_download_args (XDR *xdrs, remote_storage_vol_download_arg } bool_t +xdr_remote_domain_get_state_args (XDR *xdrs, remote_domain_get_state_args *objp) +{ + + if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) + return FALSE; + return TRUE; +} + +bool_t +xdr_remote_domain_get_state_ret (XDR *xdrs, remote_domain_get_state_ret *objp) +{ + + if (!xdr_int (xdrs, &objp->state)) + return FALSE; + if (!xdr_int (xdrs, &objp->reason)) + return FALSE; + return TRUE; +} + +bool_t xdr_remote_procedure (XDR *xdrs, remote_procedure *objp) { diff --git a/src/remote/remote_protocol.h b/src/remote/remote_protocol.h index d9bf151..fc68ca5 100644 --- a/src/remote/remote_protocol.h +++ b/src/remote/remote_protocol.h @@ -2200,6 +2200,17 @@ struct remote_storage_vol_download_args { u_int flags; }; typedef struct remote_storage_vol_download_args remote_storage_vol_download_args; + +struct remote_domain_get_state_args { + remote_nonnull_domain dom; +}; +typedef struct remote_domain_get_state_args remote_domain_get_state_args; + +struct remote_domain_get_state_ret { + int state; + int reason; +}; +typedef struct remote_domain_get_state_ret remote_domain_get_state_ret; #define REMOTE_PROGRAM 0x20008086 #define REMOTE_PROTOCOL_VERSION 1 @@ -2413,6 +2424,7 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED = 207, REMOTE_PROC_STORAGE_VOL_UPLOAD = 208, REMOTE_PROC_STORAGE_VOL_DOWNLOAD = 209, + REMOTE_PROC_DOMAIN_GET_STATE = 210, }; typedef enum remote_procedure remote_procedure; @@ -2796,6 +2808,8 @@ extern bool_t xdr_remote_domain_snapshot_delete_args (XDR *, remote_domain_snap extern bool_t xdr_remote_domain_open_console_args (XDR *, remote_domain_open_console_args*); extern bool_t xdr_remote_storage_vol_upload_args (XDR *, remote_storage_vol_upload_args*); extern bool_t xdr_remote_storage_vol_download_args (XDR *, remote_storage_vol_download_args*); +extern bool_t xdr_remote_domain_get_state_args (XDR *, remote_domain_get_state_args*); +extern bool_t xdr_remote_domain_get_state_ret (XDR *, remote_domain_get_state_ret*); extern bool_t xdr_remote_procedure (XDR *, remote_procedure*); extern bool_t xdr_remote_message_type (XDR *, remote_message_type*); extern bool_t xdr_remote_message_status (XDR *, remote_message_status*); @@ -3153,6 +3167,8 @@ extern bool_t xdr_remote_domain_snapshot_delete_args (); extern bool_t xdr_remote_domain_open_console_args (); extern bool_t xdr_remote_storage_vol_upload_args (); extern bool_t xdr_remote_storage_vol_download_args (); +extern bool_t xdr_remote_domain_get_state_args (); +extern bool_t xdr_remote_domain_get_state_ret (); extern bool_t xdr_remote_procedure (); extern bool_t xdr_remote_message_type (); extern bool_t xdr_remote_message_status (); diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 675eccd..2f65bfd 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -1940,6 +1940,15 @@ struct remote_storage_vol_download_args { unsigned int flags; }; +struct remote_domain_get_state_args { + remote_nonnull_domain dom; +}; + +struct remote_domain_get_state_ret { + int state; + int reason; +}; + /*----- Protocol. -----*/ @@ -2176,7 +2185,8 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_GET_BLKIO_PARAMETERS = 206, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED = 207, REMOTE_PROC_STORAGE_VOL_UPLOAD = 208, - REMOTE_PROC_STORAGE_VOL_DOWNLOAD = 209 + REMOTE_PROC_STORAGE_VOL_DOWNLOAD = 209, + REMOTE_PROC_DOMAIN_GET_STATE = 210 /* * Notice how the entries are grouped in sets of 10 ? diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index 944553c..84859c6 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -1427,6 +1427,13 @@ struct remote_storage_vol_download_args { uint64_t length; u_int flags; }; +struct remote_domain_get_state_args { + remote_nonnull_domain dom; +}; +struct remote_domain_get_state_ret { + int state; + int reason; +}; struct remote_message_header { u_int prog; u_int vers; -- 1.7.5.rc3

--- tools/virsh.c | 195 +++++++++++++++++++++++++++++++++++++++++++++++---------- 1 files changed, 162 insertions(+), 33 deletions(-) diff --git a/tools/virsh.c b/tools/virsh.c index 5d8b025..6dae9fa 100644 --- a/tools/virsh.c +++ b/tools/virsh.c @@ -223,6 +223,8 @@ typedef struct __vshControl { int log_fd; /* log file descriptor */ char *historydir; /* readline history directory name */ char *historyfile; /* readline history file name */ + bool noGetState; /* virDomainGetState is not supported in + * current connection */ } __vshControl; typedef struct vshCmdGrp { @@ -334,7 +336,9 @@ static void vshDebug(vshControl *ctl, int level, const char *format, ...) /* XXX: add batch support */ #define vshPrint(_ctl, ...) vshPrintExtra(NULL, __VA_ARGS__) +static int vshDomainState(vshControl *ctl, virDomainPtr dom, int *reason); static const char *vshDomainStateToString(int state); +static const char *vshDomainStateReasonToString(int state, int reason); static const char *vshDomainVcpuStateToString(int state); static bool vshConnectionUsability(vshControl *ctl, virConnectPtr conn); @@ -571,6 +575,7 @@ vshReconnect(vshControl *ctl) { else vshError(ctl, "%s", _("Reconnected to the hypervisor")); disconnected = 0; + ctl->noGetState = false; } /* --------------- @@ -717,6 +722,7 @@ cmdConnect(vshControl *ctl, const vshCmd *cmd) } ctl->name = vshStrdup(ctl, name); + ctl->noGetState = false; ctl->readonly = ro; ctl->conn = virConnectOpenAuth(ctl->name, virConnectAuthPtrDefault, @@ -750,14 +756,14 @@ static bool cmdRunConsole(vshControl *ctl, virDomainPtr dom, const char *name) { bool ret = false; - virDomainInfo dominfo; + int state; - if (virDomainGetInfo(dom, &dominfo) < 0) { + if ((state = vshDomainState(ctl, dom, NULL)) < 0) { vshError(ctl, "%s", _("Unable to get domain status")); goto cleanup; } - if (dominfo.state == VIR_DOMAIN_SHUTOFF) { + if (state == VIR_DOMAIN_SHUTOFF) { vshError(ctl, "%s", _("The domain is not running")); goto cleanup; } @@ -872,29 +878,20 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED) vshPrintExtra(ctl, "----------------------------------\n"); for (i = 0; i < maxid; i++) { - virDomainInfo info; virDomainPtr dom = virDomainLookupByID(ctl->conn, ids[i]); - const char *state; /* this kind of work with domains is not atomic operation */ if (!dom) continue; - if (virDomainGetInfo(dom, &info) < 0) - state = _("no state"); - else - state = _(vshDomainStateToString(info.state)); - vshPrint(ctl, "%3d %-20s %s\n", virDomainGetID(dom), virDomainGetName(dom), - state); + vshDomainStateToString(vshDomainState(ctl, dom, NULL))); virDomainFree(dom); } for (i = 0; i < maxname; i++) { - virDomainInfo info; virDomainPtr dom = virDomainLookupByName(ctl->conn, names[i]); - const char *state; /* this kind of work with domains is not atomic operation */ if (!dom) { @@ -902,12 +899,10 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED) continue; } - if (virDomainGetInfo(dom, &info) < 0) - state = _("no state"); - else - state = _(vshDomainStateToString(info.state)); - - vshPrint(ctl, "%3s %-20s %s\n", "-", names[i], state); + vshPrint(ctl, "%3s %-20s %s\n", + "-", + names[i], + vshDomainStateToString(vshDomainState(ctl, dom, NULL))); virDomainFree(dom); VIR_FREE(names[i]); @@ -928,15 +923,17 @@ static const vshCmdInfo info_domstate[] = { static const vshCmdOptDef opts_domstate[] = { {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")}, + {"reason", VSH_OT_BOOL, 0, N_("also print reason for the state")}, {NULL, 0, 0, NULL} }; static bool cmdDomstate(vshControl *ctl, const vshCmd *cmd) { - virDomainInfo info; virDomainPtr dom; bool ret = true; + int showReason = vshCommandOptBool(cmd, "reason"); + int state, reason; if (!vshConnectionUsability(ctl, ctl->conn)) return false; @@ -944,12 +941,21 @@ cmdDomstate(vshControl *ctl, const vshCmd *cmd) if (!(dom = vshCommandOptDomain(ctl, cmd, NULL))) return false; - if (virDomainGetInfo(dom, &info) == 0) - vshPrint(ctl, "%s\n", - _(vshDomainStateToString(info.state))); - else + if ((state = vshDomainState(ctl, dom, &reason)) < 0) { ret = false; + goto cleanup; + } + + if (showReason) { + vshPrint(ctl, "%s (%s)\n", + _(vshDomainStateToString(state)), + vshDomainStateReasonToString(state, reason)); + } else { + vshPrint(ctl, "%s\n", + _(vshDomainStateToString(state))); + } +cleanup: virDomainFree(dom); return ret; } @@ -3023,7 +3029,6 @@ static bool cmdSetmaxmem(vshControl *ctl, const vshCmd *cmd) { virDomainPtr dom; - virDomainInfo info; int kilobytes = 0; bool ret = true; int config = vshCommandOptBool(cmd, "config"); @@ -3063,12 +3068,6 @@ cmdSetmaxmem(vshControl *ctl, const vshCmd *cmd) return false; } - if (virDomainGetInfo(dom, &info) != 0) { - virDomainFree(dom); - vshError(ctl, "%s", _("Unable to verify current MemorySize")); - return false; - } - if (flags == -1) { if (virDomainSetMaxMemory(dom, kilobytes) != 0) { vshError(ctl, "%s", _("Unable to change MaxMemorySize")); @@ -12024,10 +12023,38 @@ vshCommandStringParse(vshControl *ctl, char *cmdstr) * Misc utils * --------------- */ +static int +vshDomainState(vshControl *ctl, virDomainPtr dom, int *reason) +{ + virDomainInfo info; + + if (reason) + *reason = -1; + + if (!ctl->noGetState) { + int state; + if (virDomainGetState(dom, &state, reason) < 0) { + virErrorPtr err = virGetLastError(); + if (err && err->code == VIR_ERR_NO_SUPPORT) + ctl->noGetState = true; + else + return -1; + } else { + return state; + } + } + + /* fall back to virDomainGetInfo if virDomainGetState is not supported */ + if (virDomainGetInfo(dom, &info) < 0) + return -1; + else + return info.state; +} + static const char * vshDomainStateToString(int state) { - switch (state) { + switch ((virDomainState) state) { case VIR_DOMAIN_RUNNING: return N_("running"); case VIR_DOMAIN_BLOCKED: @@ -12040,13 +12067,114 @@ vshDomainStateToString(int state) return N_("shut off"); case VIR_DOMAIN_CRASHED: return N_("crashed"); - default: + case VIR_DOMAIN_NOSTATE: ;/*FALLTHROUGH*/ } return N_("no state"); /* = dom0 state */ } static const char * +vshDomainStateReasonToString(int state, int reason) +{ + switch ((virDomainState) state) { + case VIR_DOMAIN_NOSTATE: + switch ((virDomainNostateReason) reason) { + case VIR_DOMAIN_NOSTATE_UNKNOWN: + ; + } + break; + + case VIR_DOMAIN_RUNNING: + switch ((virDomainRunningReason) reason) { + case VIR_DOMAIN_RUNNING_BOOTED: + return N_("booted"); + case VIR_DOMAIN_RUNNING_MIGRATED: + return N_("migrated"); + case VIR_DOMAIN_RUNNING_RESTORED: + return N_("restored"); + case VIR_DOMAIN_RUNNING_FROM_SNAPSHOT: + return N_("from snapshot"); + case VIR_DOMAIN_RUNNING_UNPAUSED: + return N_("unpaused"); + case VIR_DOMAIN_RUNNING_MIGRATION_CANCELED: + return N_("migration canceled"); + case VIR_DOMAIN_RUNNING_SAVE_CANCELED: + return N_("save canceled"); + case VIR_DOMAIN_RUNNING_UNKNOWN: + ; + } + break; + + case VIR_DOMAIN_BLOCKED: + switch ((virDomainBlockedReason) reason) { + case VIR_DOMAIN_BLOCKED_UNKNOWN: + ; + } + break; + + case VIR_DOMAIN_PAUSED: + switch ((virDomainPausedReason) reason) { + case VIR_DOMAIN_PAUSED_USER: + return N_("user"); + case VIR_DOMAIN_PAUSED_MIGRATION: + return N_("migrating"); + case VIR_DOMAIN_PAUSED_SAVE: + return N_("saving"); + case VIR_DOMAIN_PAUSED_DUMP: + return N_("dumping"); + case VIR_DOMAIN_PAUSED_IOERROR: + return N_("I/O error"); + case VIR_DOMAIN_PAUSED_WATCHDOG: + return N_("watchdog"); + case VIR_DOMAIN_PAUSED_FROM_SNAPSHOT: + return N_("from snapshot"); + case VIR_DOMAIN_PAUSED_UNKNOWN: + ; + } + break; + + case VIR_DOMAIN_SHUTDOWN: + switch ((virDomainShutdownReason) reason) { + case VIR_DOMAIN_SHUTDOWN_USER: + return N_("user"); + case VIR_DOMAIN_SHUTDOWN_UNKNOWN: + ; + } + break; + + case VIR_DOMAIN_SHUTOFF: + switch ((virDomainShutoffReason) reason) { + case VIR_DOMAIN_SHUTOFF_SHUTDOWN: + return N_("shutdown"); + case VIR_DOMAIN_SHUTOFF_DESTROYED: + return N_("destroyed"); + case VIR_DOMAIN_SHUTOFF_CRASHED: + return N_("crashed"); + case VIR_DOMAIN_SHUTOFF_MIGRATED: + return N_("migrated"); + case VIR_DOMAIN_SHUTOFF_SAVED: + return N_("saved"); + case VIR_DOMAIN_SHUTOFF_FAILED: + return N_("failed"); + case VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT: + return N_("from snapshot"); + case VIR_DOMAIN_SHUTOFF_UNKNOWN: + ; + } + break; + + case VIR_DOMAIN_CRASHED: + switch ((virDomainCrashedReason) reason) { + case VIR_DOMAIN_CRASHED_UNKNOWN: + ; + } + break; + } + + return N_("unknown"); +} + +static const char * vshDomainVcpuStateToString(int state) { switch (state) { @@ -12144,6 +12272,7 @@ vshError(vshControl *ctl, const char *format, ...) VIR_FREE(str); } + /* * Initialize connection. */ -- 1.7.5.rc3

On Wed, May 04, 2011 at 17:35:42 -0600, Eric Blake wrote: Yeah, I especially wanted this for virsh list to avoid calling virDomainGetState over and over even though it is not supported. Makes sense. I don't think this is needed since it doesn't really verify anything. It just checks if virDomainGetInfo fails or not. And even if it did verify something, it's really a job of virDomainSetMaxMemory or virDomainSetMemoryFlags, virsh should only check the parameters it got from its user. Jirka

On 05/04/2011 08:45 AM, Jiri Denemark wrote: ... You definitely need this function in xen_hypervisor.c, but I still wonder if the for loop across callbacks in xen_driver.c is appropriate, given that we are trying to get rid of the secondary callback structure, or if we should just inline direct calls to the appropriate helper (I brought up this same point in my review of 2/8). After all, not all possible xen helpers implement the callback (for example, xen_inotify.c does not). That is, either we use the callback structure, and this function could be private, or we declare this function and call it directly, then we don't need an extra row in the secondary callback structure. Spacing looks awkward here (space vs. tab). You'll have tweaks to fold in a flag parameter, but overall this patch looked sane. ACK. -- Eric Blake eblake(a)redhat.com +1-801-349-2682 Libvirt virtualization library http://libvirt.org

Only in drivers which use virDomainObj, drivers that query hypervisor for domain status need to be updated separately in case their hypervisor supports this functionality. The reason is also saved into domain state XML so if a domain is not running (i.e., no state XML exists) the reason will be lost by libvirtd restart. I think this is an acceptable limitation. --- src/conf/domain_conf.c | 163 ++++++++++++++++++++++++++++++++++++++++++- src/conf/domain_conf.h | 26 +++++++- src/libvirt_private.syms | 4 + src/libxl/libxl_driver.c | 53 ++++++++------ src/lxc/lxc_driver.c | 52 ++++++++------- src/openvz/openvz_conf.c | 16 +++-- src/openvz/openvz_driver.c | 29 ++++---- src/qemu/qemu_driver.c | 66 ++++++++++-------- src/qemu/qemu_migration.c | 24 ++++--- src/qemu/qemu_process.c | 61 ++++++++++------- src/qemu/qemu_process.h | 12 +++- src/test/test_driver.c | 80 ++++++++++++---------- src/uml/uml_driver.c | 30 ++++---- src/vmware/vmware_conf.c | 3 +- src/vmware/vmware_driver.c | 33 ++++----- 15 files changed, 446 insertions(+), 206 deletions(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 2a681d9..4f1b9f3 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -369,6 +369,56 @@ VIR_ENUM_IMPL(virDomainState, VIR_DOMAIN_CRASHED+1, "shutoff", "crashed") +#define VIR_DOMAIN_NOSTATE_LAST (VIR_DOMAIN_NOSTATE_UNKNOWN + 1) +VIR_ENUM_IMPL(virDomainNostateReason, VIR_DOMAIN_NOSTATE_LAST, + "unknown") + +#define VIR_DOMAIN_RUNNING_LAST (VIR_DOMAIN_RUNNING_SAVE_CANCELED + 1) +VIR_ENUM_IMPL(virDomainRunningReason, VIR_DOMAIN_RUNNING_LAST, + "unknown", + "booted", + "migrated", + "restored", + "from snapshot", + "unpaused", + "migration canceled", + "save canceled") + +#define VIR_DOMAIN_BLOCKED_LAST (VIR_DOMAIN_BLOCKED_UNKNOWN + 1) +VIR_ENUM_IMPL(virDomainBlockedReason, VIR_DOMAIN_BLOCKED_LAST, + "unknown") + +#define VIR_DOMAIN_PAUSED_LAST (VIR_DOMAIN_PAUSED_FROM_SNAPSHOT + 1) +VIR_ENUM_IMPL(virDomainPausedReason, VIR_DOMAIN_PAUSED_LAST, + "unknown", + "user", + "migration", + "save", + "dump", + "ioerror", + "watchdog", + "from snapshot") + +#define VIR_DOMAIN_SHUTDOWN_LAST (VIR_DOMAIN_SHUTDOWN_USER + 1) +VIR_ENUM_IMPL(virDomainShutdownReason, VIR_DOMAIN_SHUTDOWN_LAST, + "unknown", + "user") + +#define VIR_DOMAIN_SHUTOFF_LAST (VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT + 1) +VIR_ENUM_IMPL(virDomainShutoffReason, VIR_DOMAIN_SHUTOFF_LAST, + "unknown", + "shutdown", + "destroyed", + "crashed", + "migrated", + "saved", + "failed", + "from snapshot") + +#define VIR_DOMAIN_CRASHED_LAST (VIR_DOMAIN_CRASHED_UNKNOWN + 1) +VIR_ENUM_IMPL(virDomainCrashedReason, VIR_DOMAIN_CRASHED_LAST, + "unknown") + VIR_ENUM_IMPL(virDomainSeclabel, VIR_DOMAIN_SECLABEL_LAST, "dynamic", "static") @@ -1059,7 +1109,8 @@ static virDomainObjPtr virDomainObjNew(virCapsPtr caps) } virDomainObjLock(domain); - domain->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(domain, VIR_DOMAIN_SHUTOFF, + VIR_DOMAIN_SHUTOFF_UNKNOWN); domain->refs = 1; virDomainSnapshotObjListInit(&domain->snapshots); @@ -6250,6 +6301,8 @@ static virDomainObjPtr virDomainObjParseXML(virCapsPtr caps, xmlNodePtr config; xmlNodePtr oldnode; virDomainObjPtr obj; + int state; + int reason = 0; if (!(obj = virDomainObjNew(caps))) return NULL; @@ -6273,7 +6326,7 @@ static virDomainObjPtr virDomainObjParseXML(virCapsPtr caps, "%s", _("missing domain state")); goto error; } - if ((obj->state = virDomainStateTypeFromString(tmp)) < 0) { + if ((state = virDomainStateTypeFromString(tmp)) < 0) { virDomainReportError(VIR_ERR_INTERNAL_ERROR, _("invalid domain state '%s'"), tmp); VIR_FREE(tmp); @@ -6281,6 +6334,18 @@ static virDomainObjPtr virDomainObjParseXML(virCapsPtr caps, } VIR_FREE(tmp); + if ((tmp = virXPathString("string(./@reason)", ctxt))) { + if ((reason = virDomainStateReasonFromString(state, tmp)) < 0) { + virDomainReportError(VIR_ERR_INTERNAL_ERROR, + _("invalid domain state reason '%s'"), tmp); + VIR_FREE(tmp); + goto error; + } + VIR_FREE(tmp); + } + + virDomainObjSetState(obj, state, reason); + if ((virXPathLong("string(./@pid)", ctxt, &val)) < 0) { virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("invalid pid")); @@ -8454,9 +8519,13 @@ static char *virDomainObjFormat(virCapsPtr caps, { char *config_xml = NULL; virBuffer buf = VIR_BUFFER_INITIALIZER; + int state; + int reason; - virBufferVSprintf(&buf, "<domstatus state='%s' pid='%d'>\n", - virDomainStateTypeToString(obj->state), + state = virDomainObjGetState(obj, &reason); + virBufferVSprintf(&buf, "<domstatus state='%s' reason='%s' pid='%d'>\n", + virDomainStateTypeToString(state), + virDomainStateReasonToString(state, reason), obj->pid); if (caps->privateDataXMLFormat && @@ -9551,3 +9620,89 @@ virDomainObjCopyPersistentDef(virCapsPtr caps, virDomainObjPtr dom) VIR_FREE(xml); return ret; } + + +virDomainState +virDomainObjGetState(virDomainObjPtr dom, int *reason) +{ + if (reason) + *reason = dom->state.reason; + + return dom->state.state; +} + + +void +virDomainObjSetState(virDomainObjPtr dom, virDomainState state, int reason) +{ + int last = -1; + + switch (state) { + case VIR_DOMAIN_NOSTATE: last = VIR_DOMAIN_NOSTATE_LAST; break; + case VIR_DOMAIN_RUNNING: last = VIR_DOMAIN_RUNNING_LAST; break; + case VIR_DOMAIN_BLOCKED: last = VIR_DOMAIN_BLOCKED_LAST; break; + case VIR_DOMAIN_PAUSED: last = VIR_DOMAIN_PAUSED_LAST; break; + case VIR_DOMAIN_SHUTDOWN: last = VIR_DOMAIN_SHUTDOWN_LAST; break; + case VIR_DOMAIN_SHUTOFF: last = VIR_DOMAIN_SHUTOFF_LAST; break; + case VIR_DOMAIN_CRASHED: last = VIR_DOMAIN_CRASHED_LAST; break; + } + + if (last < 0) { + VIR_ERROR(_("invalid domain state: %d"), state); + return; + } + + dom->state.state = state; + if (reason > 0 || reason < last) + dom->state.reason = reason; + else + dom->state.reason = 0; +} + + +const char * +virDomainStateReasonToString(virDomainState state, int reason) +{ + switch (state) { + case VIR_DOMAIN_NOSTATE: + return virDomainNostateReasonTypeToString(reason); + case VIR_DOMAIN_RUNNING: + return virDomainRunningReasonTypeToString(reason); + case VIR_DOMAIN_BLOCKED: + return virDomainBlockedReasonTypeToString(reason); + case VIR_DOMAIN_PAUSED: + return virDomainPausedReasonTypeToString(reason); + case VIR_DOMAIN_SHUTDOWN: + return virDomainShutdownReasonTypeToString(reason); + case VIR_DOMAIN_SHUTOFF: + return virDomainShutoffReasonTypeToString(reason); + case VIR_DOMAIN_CRASHED: + return virDomainCrashedReasonTypeToString(reason); + } + + return NULL; +} + + +int +virDomainStateReasonFromString(virDomainState state, const char *reason) +{ + switch (state) { + case VIR_DOMAIN_NOSTATE: + return virDomainNostateReasonTypeFromString(reason); + case VIR_DOMAIN_RUNNING: + return virDomainRunningReasonTypeFromString(reason); + case VIR_DOMAIN_BLOCKED: + return virDomainBlockedReasonTypeFromString(reason); + case VIR_DOMAIN_PAUSED: + return virDomainPausedReasonTypeFromString(reason); + case VIR_DOMAIN_SHUTDOWN: + return virDomainShutdownReasonTypeFromString(reason); + case VIR_DOMAIN_SHUTOFF: + return virDomainShutoffReasonTypeFromString(reason); + case VIR_DOMAIN_CRASHED: + return virDomainCrashedReasonTypeFromString(reason); + } + + return -1; +} diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h index 1dadf98..4a6ad4e 100644 --- a/src/conf/domain_conf.h +++ b/src/conf/domain_conf.h @@ -1183,6 +1183,12 @@ struct _virDomainDef { }; /* Guest VM runtime state */ +typedef struct _virDomainStateReason virDomainStateReason; +struct _virDomainStateReason { + int state; + int reason; +}; + typedef struct _virDomainObj virDomainObj; typedef virDomainObj *virDomainObjPtr; struct _virDomainObj { @@ -1190,7 +1196,7 @@ struct _virDomainObj { int refs; int pid; - int state; + virDomainStateReason state; unsigned int autostart : 1; unsigned int persistent : 1; @@ -1426,6 +1432,13 @@ int virDomainDiskDefForeachPath(virDomainDiskDefPtr disk, virDomainDiskDefPathIterator iter, void *opaque); +void +virDomainObjSetState(virDomainObjPtr obj, virDomainState state, int reason) + ATTRIBUTE_NONNULL(1); +virDomainState +virDomainObjGetState(virDomainObjPtr obj, int *reason) + ATTRIBUTE_NONNULL(1); + typedef const char* (*virLifecycleToStringFunc)(int type); typedef int (*virLifecycleFromStringFunc)(const char *type); @@ -1478,6 +1491,17 @@ VIR_ENUM_DECL(virDomainGraphicsSpiceZlibCompression) VIR_ENUM_DECL(virDomainGraphicsSpicePlaybackCompression) /* from libvirt.h */ VIR_ENUM_DECL(virDomainState) +VIR_ENUM_DECL(virDomainNostateReason) +VIR_ENUM_DECL(virDomainRunningReason) +VIR_ENUM_DECL(virDomainBlockedReason) +VIR_ENUM_DECL(virDomainPausedReason) +VIR_ENUM_DECL(virDomainShutdownReason) +VIR_ENUM_DECL(virDomainShutoffReason) +VIR_ENUM_DECL(virDomainCrashedReason) + +const char *virDomainStateReasonToString(virDomainState state, int reason); +int virDomainStateReasonFromString(virDomainState state, const char *reason); + VIR_ENUM_DECL(virDomainSeclabel) VIR_ENUM_DECL(virDomainClockOffset) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 1b22be6..2dc6d9c 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -291,6 +291,7 @@ virDomainNetTypeToString; virDomainObjAssignDef; virDomainObjCopyPersistentDef; virDomainObjGetPersistentDef; +virDomainObjGetState; virDomainObjIsDuplicate; virDomainObjListDeinit; virDomainObjListGetActiveIDs; @@ -300,6 +301,7 @@ virDomainObjListNumOfDomains; virDomainObjLock; virDomainObjRef; virDomainObjSetDefTransient; +virDomainObjSetState; virDomainObjUnlock; virDomainObjUnref; virDomainRemoveInactive; @@ -322,6 +324,8 @@ virDomainSnapshotObjListRemove; virDomainSoundDefFree; virDomainSoundModelTypeFromString; virDomainSoundModelTypeToString; +virDomainStateReasonFromString; +virDomainStateReasonToString; virDomainStateTypeFromString; virDomainStateTypeToString; virDomainTimerModeTypeFromString; diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c index 7d62ed5..35a1f7d 100644 --- a/src/libxl/libxl_driver.c +++ b/src/libxl/libxl_driver.c @@ -245,7 +245,9 @@ libxlDoNodeGetInfo(libxlDriverPrivatePtr driver, virNodeInfoPtr info) * virDomainObjPtr should be locked on invocation */ static void -libxlVmCleanup(libxlDriverPrivatePtr driver, virDomainObjPtr vm) +libxlVmCleanup(libxlDriverPrivatePtr driver, + virDomainObjPtr vm, + virDomainShutoffReason reason) { libxlDomainObjPrivatePtr priv = vm->privateData; int vnc_port; @@ -265,7 +267,7 @@ libxlVmCleanup(libxlDriverPrivatePtr driver, virDomainObjPtr vm) if (vm->persistent) { vm->def->id = -1; - vm->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason); } if ((vm->def->ngraphics == 1) && @@ -302,7 +304,10 @@ libxlVmCleanup(libxlDriverPrivatePtr driver, virDomainObjPtr vm) * virDomainObjPtr should be locked on invocation */ static int -libxlVmReap(libxlDriverPrivatePtr driver, virDomainObjPtr vm, int force) +libxlVmReap(libxlDriverPrivatePtr driver, + virDomainObjPtr vm, + int force, + virDomainShutoffReason reason) { libxlDomainObjPrivatePtr priv = vm->privateData; @@ -312,7 +317,7 @@ libxlVmReap(libxlDriverPrivatePtr driver, virDomainObjPtr vm, int force) return -1; } - libxlVmCleanup(driver, vm); + libxlVmCleanup(driver, vm, reason); return 0; } @@ -353,6 +358,8 @@ static void libxlEventHandler(int watch, goto cleanup; if (event.type == LIBXL_EVENT_DOMAIN_DEATH) { + virDomainShutoffReason reason; + /* libxl_event_get_domain_death_info returns 1 if death * event was for this domid */ if (libxl_event_get_domain_death_info(&priv->ctx, @@ -366,18 +373,22 @@ static void libxlEventHandler(int watch, switch (info.shutdown_reason) { case SHUTDOWN_poweroff: case SHUTDOWN_crash: - if (info.shutdown_reason == SHUTDOWN_crash) + if (info.shutdown_reason == SHUTDOWN_crash) { dom_event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_CRASHED); - libxlVmReap(driver, vm, 0); + reason = VIR_DOMAIN_SHUTOFF_CRASHED; + } else { + reason = VIR_DOMAIN_SHUTOFF_SHUTDOWN; + } + libxlVmReap(driver, vm, 0, reason); if (!vm->persistent) { virDomainRemoveInactive(&driver->domains, vm); vm = NULL; } break; case SHUTDOWN_reboot: - libxlVmReap(driver, vm, 0); + libxlVmReap(driver, vm, 0, VIR_DOMAIN_SHUTOFF_SHUTDOWN); libxlVmStart(driver, vm, 0); break; default: @@ -552,9 +563,9 @@ libxlVmStart(libxlDriverPrivatePtr driver, if (!start_paused) { libxl_domain_unpause(&priv->ctx, domid); - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED); } else { - vm->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); } @@ -573,7 +584,7 @@ error: if (domid > 0) { libxl_domain_destroy(&priv->ctx, domid, 0); def->id = -1; - vm->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, VIR_DOMAIN_SHUTOFF_FAILED); } libxl_domain_config_destroy(&d_config); VIR_FREE(dom_xml); @@ -618,7 +629,7 @@ libxlReconnectDomain(void *payload, /* Update domid in case it changed (e.g. reboot) while we were gone? */ vm->def->id = d_info.domid; - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNKNOWN); /* Recreate domain death et. al. events */ libxlCreateDomEvents(vm); @@ -626,7 +637,7 @@ libxlReconnectDomain(void *payload, return; out: - libxlVmCleanup(driver, vm); + libxlVmCleanup(driver, vm, VIR_DOMAIN_SHUTOFF_UNKNOWN); if (!vm->persistent) virDomainRemoveInactive(&driver->domains, vm); else @@ -1169,7 +1180,7 @@ libxlDomainSuspend(virDomainPtr dom) priv = vm->privateData; - if (vm->state != VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) { if (libxl_domain_pause(&priv->ctx, dom->id) != 0) { libxlError(VIR_ERR_INTERNAL_ERROR, _("Failed to suspend domain '%d' with libxenlight"), @@ -1177,7 +1188,7 @@ libxlDomainSuspend(virDomainPtr dom) goto cleanup; } - vm->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); @@ -1228,7 +1239,7 @@ libxlDomainResume(virDomainPtr dom) priv = vm->privateData; - if (vm->state == VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { if (libxl_domain_unpause(&priv->ctx, dom->id) != 0) { libxlError(VIR_ERR_INTERNAL_ERROR, _("Failed to resume domain '%d' with libxenlight"), @@ -1236,7 +1247,8 @@ libxlDomainResume(virDomainPtr dom) goto cleanup; } - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_UNPAUSED); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_UNPAUSED); @@ -1371,7 +1383,7 @@ libxlDomainDestroy(virDomainPtr dom) VIR_DOMAIN_EVENT_STOPPED_DESTROYED); priv = vm->privateData; - if (libxlVmReap(driver, vm, 1) != 0) { + if (libxlVmReap(driver, vm, 1, VIR_DOMAIN_SHUTOFF_DESTROYED) != 0) { libxlError(VIR_ERR_INTERNAL_ERROR, _("Failed to destroy domain '%d'"), dom->id); goto cleanup; @@ -1554,7 +1566,7 @@ libxlDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) info->memory = d_info.current_memkb; } - info->state = vm->state; + info->state = virDomainObjGetState(vm, NULL); info->maxMem = vm->def->mem.max_balloon; info->nrVirtCpu = vm->def->vcpus; ret = 0; @@ -1582,10 +1594,7 @@ libxlDomainGetState(virDomainPtr dom, int *state, int *reason) goto cleanup; } - *state = vm->state; - if (reason) - *reason = 0; - + *state = virDomainObjGetState(vm, reason); ret = 0; cleanup: diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c index ccedfe3..1eae10a 100644 --- a/src/lxc/lxc_driver.c +++ b/src/lxc/lxc_driver.c @@ -522,7 +522,7 @@ static int lxcDomainGetInfo(virDomainPtr dom, goto cleanup; } - info->state = vm->state; + info->state = virDomainObjGetState(vm, NULL); if (!virDomainObjIsActive(vm) || driver->cgroup == NULL) { info->cpuTime = 0; @@ -583,10 +583,7 @@ lxcDomainGetState(virDomainPtr dom, int *state, int *reason) goto cleanup; } - *state = vm->state; - if (reason) - *reason = 0; - + *state = virDomainObjGetState(vm, reason); ret = 0; cleanup: @@ -979,15 +976,16 @@ cleanup: /** * lxcVmCleanup: - * @conn: pointer to connection * @driver: pointer to driver structure * @vm: pointer to VM to clean up + * @reason: reason for switching the VM to shutoff state * * Cleanout resources associated with the now dead VM * */ static void lxcVmCleanup(lxc_driver_t *driver, - virDomainObjPtr vm) + virDomainObjPtr vm, + virDomainShutoffReason reason) { virCgroupPtr cgroup; int i; @@ -1009,7 +1007,7 @@ static void lxcVmCleanup(lxc_driver_t *driver, virFileDeletePid(driver->stateDir, vm->def->name); virDomainDeleteConfig(driver->stateDir, NULL, vm); - vm->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason); vm->pid = -1; vm->def->id = -1; priv->monitor = -1; @@ -1194,7 +1192,8 @@ error: static int lxcVmTerminate(lxc_driver_t *driver, - virDomainObjPtr vm) + virDomainObjPtr vm, + virDomainShutoffReason reason) { virCgroupPtr group = NULL; int rc; @@ -1221,7 +1220,7 @@ static int lxcVmTerminate(lxc_driver_t *driver, rc = -1; goto cleanup; } - lxcVmCleanup(driver, vm); + lxcVmCleanup(driver, vm, reason); rc = 0; @@ -1251,7 +1250,7 @@ static void lxcMonitorEvent(int watch, goto cleanup; } - if (lxcVmTerminate(driver, vm) < 0) { + if (lxcVmTerminate(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN) < 0) { virEventRemoveHandle(watch); } else { event = virDomainEventNewFromObj(vm, @@ -1477,6 +1476,7 @@ cleanup: * @conn: pointer to connection * @driver: pointer to driver structure * @vm: pointer to virtual machine structure + * @reason: reason for switching vm to running state * * Starts a vm * @@ -1484,7 +1484,8 @@ cleanup: */ static int lxcVmStart(virConnectPtr conn, lxc_driver_t * driver, - virDomainObjPtr vm) + virDomainObjPtr vm, + virDomainRunningReason reason) { int rc = -1, r; unsigned int i; @@ -1584,14 +1585,14 @@ static int lxcVmStart(virConnectPtr conn, } vm->def->id = vm->pid; - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, reason); if ((priv->monitorWatch = virEventAddHandle( priv->monitor, VIR_EVENT_HANDLE_ERROR | VIR_EVENT_HANDLE_HANGUP, lxcMonitorEvent, vm, NULL)) < 0) { - lxcVmTerminate(driver, vm); + lxcVmTerminate(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED); goto cleanup; } @@ -1664,7 +1665,7 @@ static int lxcDomainStartWithFlags(virDomainPtr dom, unsigned int flags) goto cleanup; } - ret = lxcVmStart(dom->conn, driver, vm); + ret = lxcVmStart(dom->conn, driver, vm, VIR_DOMAIN_RUNNING_BOOTED); if (ret == 0) event = virDomainEventNewFromObj(vm, @@ -1735,7 +1736,7 @@ lxcDomainCreateAndStart(virConnectPtr conn, goto cleanup; def = NULL; - if (lxcVmStart(conn, driver, vm) < 0) { + if (lxcVmStart(conn, driver, vm, VIR_DOMAIN_RUNNING_BOOTED) < 0) { virDomainRemoveInactive(&driver->domains, vm); vm = NULL; goto cleanup; @@ -1926,7 +1927,7 @@ static int lxcDomainDestroy(virDomainPtr dom) goto cleanup; } - ret = lxcVmTerminate(driver, vm); + ret = lxcVmTerminate(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); @@ -1974,7 +1975,8 @@ lxcAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaqu virDomainObjLock(vm); if (vm->autostart && !virDomainObjIsActive(vm)) { - int ret = lxcVmStart(data->conn, data->driver, vm); + int ret = lxcVmStart(data->conn, data->driver, vm, + VIR_DOMAIN_RUNNING_BOOTED); if (ret < 0) { virErrorPtr err = virGetLastError(); VIR_ERROR(_("Failed to autostart VM '%s': %s"), @@ -2048,14 +2050,15 @@ lxcReconnectVM(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque) if (vm->pid != 0) { vm->def->id = vm->pid; - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_UNKNOWN); if ((priv->monitorWatch = virEventAddHandle( priv->monitor, VIR_EVENT_HANDLE_ERROR | VIR_EVENT_HANDLE_HANGUP, lxcMonitorEvent, vm, NULL)) < 0) { - lxcVmTerminate(driver, vm); + lxcVmTerminate(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED); goto cleanup; } } else { @@ -2669,13 +2672,13 @@ static int lxcDomainSuspend(virDomainPtr dom) goto cleanup; } - if (vm->state != VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) { if (lxcFreezeContainer(driver, vm) < 0) { lxcError(VIR_ERR_OPERATION_FAILED, "%s", _("Suspend operation failed")); goto cleanup; } - vm->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, @@ -2734,13 +2737,14 @@ static int lxcDomainResume(virDomainPtr dom) goto cleanup; } - if (vm->state == VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { if (lxcUnfreezeContainer(driver, vm) < 0) { lxcError(VIR_ERR_OPERATION_FAILED, "%s", _("Resume operation failed")); goto cleanup; } - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_UNPAUSED); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, diff --git a/src/openvz/openvz_conf.c b/src/openvz/openvz_conf.c index 88cd4c8..8c6261f 100644 --- a/src/openvz/openvz_conf.c +++ b/src/openvz/openvz_conf.c @@ -484,14 +484,20 @@ int openvzLoadDomains(struct openvz_driver *driver) { if (VIR_ALLOC(dom->def) < 0) goto no_memory; - if (STREQ(status, "stopped")) - dom->state = VIR_DOMAIN_SHUTOFF; - else - dom->state = VIR_DOMAIN_RUNNING; + if (STREQ(status, "stopped")) { + virDomainObjSetState(dom, VIR_DOMAIN_SHUTOFF, + VIR_DOMAIN_SHUTOFF_UNKNOWN); + } else { + virDomainObjSetState(dom, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_UNKNOWN); + } dom->refs = 1; dom->pid = veid; - dom->def->id = dom->state == VIR_DOMAIN_SHUTOFF ? -1 : veid; + if (virDomainObjGetState(dom, NULL) == VIR_DOMAIN_SHUTOFF) + dom->def->id = -1; + else + dom->def->id = veid; /* XXX OpenVZ doesn't appear to have concept of a transient domain */ dom->persistent = 1; diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c index 0e774d9..458dc6f 100644 --- a/src/openvz/openvz_driver.c +++ b/src/openvz/openvz_driver.c @@ -353,7 +353,7 @@ static int openvzDomainGetInfo(virDomainPtr dom, goto cleanup; } - info->state = vm->state; + info->state = virDomainObjGetState(vm, NULL); if (!virDomainObjIsActive(vm)) { info->cpuTime = 0; @@ -394,10 +394,7 @@ openvzDomainGetState(virDomainPtr dom, int *state, int *reason) goto cleanup; } - *state = vm->state; - if (reason) - *reason = 0; - + *state = virDomainObjGetState(vm, reason); ret = 0; cleanup: @@ -520,12 +517,12 @@ static int openvzDomainSuspend(virDomainPtr dom) { goto cleanup; } - if (vm->state != VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) { openvzSetProgramSentinal(prog, vm->def->name); if (virRun(prog, NULL) < 0) { goto cleanup; } - vm->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); } ret = 0; @@ -558,12 +555,12 @@ static int openvzDomainResume(virDomainPtr dom) { goto cleanup; } - if (vm->state == VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { openvzSetProgramSentinal(prog, vm->def->name); if (virRun(prog, NULL) < 0) { goto cleanup; } - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED); } ret = 0; @@ -591,7 +588,7 @@ static int openvzDomainShutdown(virDomainPtr dom) { } openvzSetProgramSentinal(prog, vm->def->name); - if (vm->state != VIR_DOMAIN_RUNNING) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) { openvzError(VIR_ERR_INTERNAL_ERROR, "%s", _("domain is not in running state")); goto cleanup; @@ -601,7 +598,7 @@ static int openvzDomainShutdown(virDomainPtr dom) { goto cleanup; vm->def->id = -1; - vm->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, VIR_DOMAIN_SHUTOFF_SHUTDOWN); dom->id = -1; ret = 0; @@ -629,7 +626,7 @@ static int openvzDomainReboot(virDomainPtr dom, } openvzSetProgramSentinal(prog, vm->def->name); - if (vm->state != VIR_DOMAIN_RUNNING) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) { openvzError(VIR_ERR_INTERNAL_ERROR, "%s", _("domain is not in running state")); goto cleanup; @@ -639,6 +636,8 @@ static int openvzDomainReboot(virDomainPtr dom, goto cleanup; ret = 0; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED); + cleanup: if (vm) virDomainObjUnlock(vm); @@ -1017,7 +1016,7 @@ openvzDomainCreateXML(virConnectPtr conn, const char *xml, vm->pid = strtoI(vm->def->name); vm->def->id = vm->pid; - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED); if (vm->def->maxvcpus > 0) { if (openvzDomainSetVcpusInternal(vm, vm->def->maxvcpus) < 0) { @@ -1059,7 +1058,7 @@ openvzDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) goto cleanup; } - if (vm->state != VIR_DOMAIN_SHUTOFF) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_SHUTOFF) { openvzError(VIR_ERR_OPERATION_DENIED, "%s", _("domain is not in shutoff state")); goto cleanup; @@ -1073,7 +1072,7 @@ openvzDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) vm->pid = strtoI(vm->def->name); vm->def->id = vm->pid; dom->id = vm->pid; - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED); ret = 0; cleanup: diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 1fc4a22..3efb1a8 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -1325,7 +1325,7 @@ static int qemudDomainSuspend(virDomainPtr dom) { priv = vm->privateData; if (priv->jobActive == QEMU_JOB_MIGRATION_OUT) { - if (vm->state != VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) { VIR_DEBUG("Requesting domain pause on %s", vm->def->name); priv->jobSignals |= QEMU_JOB_SIGNAL_SUSPEND; @@ -1341,8 +1341,8 @@ static int qemudDomainSuspend(virDomainPtr dom) { "%s", _("domain is not running")); goto endjob; } - if (vm->state != VIR_DOMAIN_PAUSED) { - if (qemuProcessStopCPUs(driver, vm) < 0) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) { + if (qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_USER) < 0) { goto endjob; } event = virDomainEventNewFromObj(vm, @@ -1394,8 +1394,9 @@ static int qemudDomainResume(virDomainPtr dom) { "%s", _("domain is not running")); goto endjob; } - if (vm->state == VIR_DOMAIN_PAUSED) { - if (qemuProcessStartCPUs(driver, vm, dom->conn) < 0) { + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { + if (qemuProcessStartCPUs(driver, vm, dom->conn, + VIR_DOMAIN_RUNNING_UNPAUSED) < 0) { if (virGetLastError() == NULL) qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", _("resume operation failed")); @@ -1491,7 +1492,7 @@ static int qemudDomainDestroy(virDomainPtr dom) { goto endjob; } - qemuProcessStop(driver, vm, 0); + qemuProcessStop(driver, vm, 0, VIR_DOMAIN_SHUTOFF_DESTROYED); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); @@ -1725,7 +1726,7 @@ static int qemudDomainGetInfo(virDomainPtr dom, goto cleanup; } - info->state = vm->state; + info->state = virDomainObjGetState(vm, NULL); if (!virDomainObjIsActive(vm)) { info->cpuTime = 0; @@ -1802,10 +1803,7 @@ qemuDomainGetState(virDomainPtr dom, int *state, int *reason) goto cleanup; } - *state = vm->state; - if (reason) - *reason = 0; - + *state = virDomainObjGetState(vm, reason); ret = 0; cleanup: @@ -1932,9 +1930,9 @@ static int qemudDomainSaveFlag(struct qemud_driver *driver, virDomainPtr dom, priv->jobInfo.type = VIR_DOMAIN_JOB_UNBOUNDED; /* Pause */ - if (vm->state == VIR_DOMAIN_RUNNING) { + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { header.was_running = 1; - if (qemuProcessStopCPUs(driver, vm) < 0) + if (qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_SAVE) < 0) goto endjob; if (!virDomainObjIsActive(vm)) { @@ -2086,7 +2084,7 @@ static int qemudDomainSaveFlag(struct qemud_driver *driver, virDomainPtr dom, ret = 0; /* Shut it down */ - qemuProcessStop(driver, vm, 0); + qemuProcessStop(driver, vm, 0, VIR_DOMAIN_SHUTOFF_SAVED); qemuAuditDomainStop(vm, "saved"); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, @@ -2102,7 +2100,8 @@ endjob: if (vm) { if (ret != 0) { if (header.was_running && virDomainObjIsActive(vm)) { - rc = qemuProcessStartCPUs(driver, vm, dom->conn); + rc = qemuProcessStartCPUs(driver, vm, dom->conn, + VIR_DOMAIN_RUNNING_SAVE_CANCELED); if (rc < 0) VIR_WARN0("Unable to resume guest CPUs after save failure"); } @@ -2415,11 +2414,12 @@ static int qemudDomainCoreDump(virDomainPtr dom, /* Migrate will always stop the VM, so the resume condition is independent of whether the stop command is issued. */ - resume = (vm->state == VIR_DOMAIN_RUNNING); + resume = virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING; /* Pause domain for non-live dump */ - if (!(flags & VIR_DUMP_LIVE) && vm->state == VIR_DOMAIN_RUNNING) { - if (qemuProcessStopCPUs(driver, vm) < 0) + if (!(flags & VIR_DUMP_LIVE) && + virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { + if (qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_DUMP) < 0) goto endjob; paused = 1; @@ -2438,7 +2438,7 @@ static int qemudDomainCoreDump(virDomainPtr dom, endjob: if ((ret == 0) && (flags & VIR_DUMP_CRASH)) { - qemuProcessStop(driver, vm, 0); + qemuProcessStop(driver, vm, 0, VIR_DOMAIN_SHUTOFF_CRASHED); qemuAuditDomainStop(vm, "crashed"); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, @@ -2449,7 +2449,8 @@ endjob: will support synchronous operations so we always get here after the migration is complete. */ else if (resume && paused && virDomainObjIsActive(vm)) { - if (qemuProcessStartCPUs(driver, vm, dom->conn) < 0) { + if (qemuProcessStartCPUs(driver, vm, dom->conn, + VIR_DOMAIN_RUNNING_UNPAUSED) < 0) { if (virGetLastError() == NULL) qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", _("resuming after dump failed")); @@ -2515,7 +2516,8 @@ static void processWatchdogEvent(void *data, void *opaque) qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", _("Dump failed")); - ret = qemuProcessStartCPUs(driver, wdEvent->vm, NULL); + ret = qemuProcessStartCPUs(driver, wdEvent->vm, NULL, + VIR_DOMAIN_RUNNING_UNPAUSED); if (ret < 0) qemuReportError(VIR_ERR_OPERATION_FAILED, @@ -3213,7 +3215,8 @@ qemuDomainSaveImageStartVM(virConnectPtr conn, /* If it was running before, resume it now. */ if (header->was_running) { - if (qemuProcessStartCPUs(driver, vm, conn) < 0) { + if (qemuProcessStartCPUs(driver, vm, conn, + VIR_DOMAIN_RUNNING_RESTORED) < 0) { if (virGetLastError() == NULL) qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", _("failed to resume domain")); @@ -6360,12 +6363,12 @@ qemuDomainSnapshotCreateActive(virConnectPtr conn, if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0) return -1; - if (vm->state == VIR_DOMAIN_RUNNING) { + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { /* savevm monitor command pauses the domain emitting an event which * confuses libvirt since it's not notified when qemu resumes the * domain. Thus we stop and start CPUs ourselves. */ - if (qemuProcessStopCPUs(driver, vm) < 0) + if (qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_SAVE) < 0) goto cleanup; resume = true; @@ -6382,7 +6385,8 @@ qemuDomainSnapshotCreateActive(virConnectPtr conn, cleanup: if (resume && virDomainObjIsActive(vm) && - qemuProcessStartCPUs(driver, vm, conn) < 0 && + qemuProcessStartCPUs(driver, vm, conn, + VIR_DOMAIN_RUNNING_UNPAUSED) < 0 && virGetLastError() == NULL) { qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", _("resuming after snapshot failed")); @@ -6432,7 +6436,7 @@ static virDomainSnapshotPtr qemuDomainSnapshotCreateXML(virDomainPtr domain, if (!(snap = virDomainSnapshotAssignDef(&vm->snapshots, def))) goto cleanup; - snap->def->state = vm->state; + snap->def->state = virDomainObjGetState(vm, NULL); /* actually do the snapshot */ if (!virDomainObjIsActive(vm)) { @@ -6732,9 +6736,13 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, /* qemu unconditionally starts the domain running again after * loadvm, so let's pause it to keep consistency */ - rc = qemuProcessStopCPUs(driver, vm); + rc = qemuProcessStopCPUs(driver, vm, + VIR_DOMAIN_PAUSED_FROM_SNAPSHOT); if (rc < 0) goto endjob; + } else { + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_FROM_SNAPSHOT); } event = virDomainEventNewFromObj(vm, @@ -6753,7 +6761,7 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, */ if (virDomainObjIsActive(vm)) { - qemuProcessStop(driver, vm, 0); + qemuProcessStop(driver, vm, 0, VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT); qemuAuditDomainStop(vm, "from-snapshot"); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, @@ -6770,8 +6778,6 @@ static int qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, goto endjob; } - vm->state = snap->def->state; - ret = 0; endjob: diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 7f4b111..956ac78 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -65,7 +65,7 @@ qemuMigrationSetOffline(struct qemud_driver *driver, { int ret; - ret = qemuProcessStopCPUs(driver, vm); + ret = qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_MIGRATION); if (ret == 0) { virDomainEventPtr event; @@ -334,7 +334,7 @@ qemuMigrationPrepareTunnel(struct qemud_driver *driver, if (virFDStreamOpen(st, dataFD[1]) < 0) { qemuAuditDomainStart(vm, "migrated", false); - qemuProcessStop(driver, vm, 0); + qemuProcessStop(driver, vm, 0, VIR_DOMAIN_SHUTOFF_FAILED); if (!vm->persistent) { if (qemuDomainObjEndJob(vm) > 0) virDomainRemoveInactive(&driver->domains, vm); @@ -1066,8 +1066,9 @@ int qemuMigrationPerform(struct qemud_driver *driver, memset(&priv->jobInfo, 0, sizeof(priv->jobInfo)); priv->jobInfo.type = VIR_DOMAIN_JOB_UNBOUNDED; - resume = vm->state == VIR_DOMAIN_RUNNING; - if (!(flags & VIR_MIGRATE_LIVE) && vm->state == VIR_DOMAIN_RUNNING) { + resume = virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING; + if (!(flags & VIR_MIGRATE_LIVE) && + virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { if (qemuMigrationSetOffline(driver, vm) < 0) goto endjob; } @@ -1082,7 +1083,7 @@ int qemuMigrationPerform(struct qemud_driver *driver, } /* Clean up the source domain. */ - qemuProcessStop(driver, vm, 1); + qemuProcessStop(driver, vm, 1, VIR_DOMAIN_SHUTOFF_MIGRATED); qemuAuditDomainStop(vm, "migrated"); resume = 0; @@ -1098,9 +1099,10 @@ int qemuMigrationPerform(struct qemud_driver *driver, ret = 0; endjob: - if (resume && vm->state == VIR_DOMAIN_PAUSED) { + if (resume && virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { /* we got here through some sort of failure; start the domain again */ - if (qemuProcessStartCPUs(driver, vm, conn) < 0) { + if (qemuProcessStartCPUs(driver, vm, conn, + VIR_DOMAIN_RUNNING_MIGRATION_CANCELED) < 0) { /* Hm, we already know we are in error here. We don't want to * overwrite the previous error, though, so we just throw something * to the logs and hope for the best @@ -1239,7 +1241,8 @@ qemuMigrationFinish(struct qemud_driver *driver, * >= 0.10.6 to work properly. This isn't strictly necessary on * older qemu's, but it also doesn't hurt anything there */ - if (qemuProcessStartCPUs(driver, vm, dconn) < 0) { + if (qemuProcessStartCPUs(driver, vm, dconn, + VIR_DOMAIN_RUNNING_MIGRATED) < 0) { if (virGetLastError() == NULL) qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("resume operation failed")); @@ -1250,7 +1253,8 @@ qemuMigrationFinish(struct qemud_driver *driver, event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_MIGRATED); - if (vm->state == VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) { + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); qemuDomainEventQueue(driver, event); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, @@ -1261,7 +1265,7 @@ qemuMigrationFinish(struct qemud_driver *driver, goto endjob; } } else { - qemuProcessStop(driver, vm, 1); + qemuProcessStop(driver, vm, 1, VIR_DOMAIN_SHUTOFF_FAILED); qemuAuditDomainStop(vm, "failed"); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED, diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 7691cbe..c685c82 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -132,7 +132,10 @@ qemuProcessHandleMonitorEOF(qemuMonitorPtr mon ATTRIBUTE_UNUSED, VIR_DOMAIN_EVENT_STOPPED_FAILED : VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); - qemuProcessStop(driver, vm, 0); + qemuProcessStop(driver, vm, 0, + hasError ? + VIR_DOMAIN_SHUTOFF_CRASHED : + VIR_DOMAIN_SHUTOFF_SHUTDOWN); qemuAuditDomainStop(vm, hasError ? "failed" : "shutdown"); if (!vm->persistent) @@ -340,11 +343,11 @@ qemuProcessHandleStop(qemuMonitorPtr mon ATTRIBUTE_UNUSED, virDomainEventPtr event = NULL; virDomainObjLock(vm); - if (vm->state == VIR_DOMAIN_RUNNING) { + if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { VIR_DEBUG("Transitioned guest %s to paused state due to unknown event", vm->def->name); - vm->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_UNKNOWN); event = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); @@ -409,10 +412,10 @@ qemuProcessHandleWatchdog(qemuMonitorPtr mon ATTRIBUTE_UNUSED, watchdogEvent = virDomainEventWatchdogNewFromObj(vm, action); if (action == VIR_DOMAIN_EVENT_WATCHDOG_PAUSE && - vm->state == VIR_DOMAIN_RUNNING) { + virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { VIR_DEBUG("Transitioned guest %s to paused state due to watchdog", vm->def->name); - vm->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_WATCHDOG); lifecycleEvent = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG); @@ -488,10 +491,10 @@ qemuProcessHandleIOError(qemuMonitorPtr mon ATTRIBUTE_UNUSED, ioErrorEvent2 = virDomainEventIOErrorReasonNewFromObj(vm, srcPath, devAlias, action, reason); if (action == VIR_DOMAIN_EVENT_IO_ERROR_PAUSE && - vm->state == VIR_DOMAIN_RUNNING) { + virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { VIR_DEBUG("Transitioned guest %s to paused state due to IO error", vm->def->name); - vm->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_IOERROR); lifecycleEvent = virDomainEventNewFromObj(vm, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_IOERROR); @@ -1893,7 +1896,7 @@ qemuProcessPrepareMonitorChr(struct qemud_driver *driver, int qemuProcessStartCPUs(struct qemud_driver *driver, virDomainObjPtr vm, - virConnectPtr conn) + virConnectPtr conn, virDomainRunningReason reason) { int ret; qemuDomainObjPrivatePtr priv = vm->privateData; @@ -1901,27 +1904,32 @@ qemuProcessStartCPUs(struct qemud_driver *driver, virDomainObjPtr vm, qemuDomainObjEnterMonitorWithDriver(driver, vm); ret = qemuMonitorStartCPUs(priv->mon, conn); qemuDomainObjExitMonitorWithDriver(driver, vm); - if (ret == 0) { - vm->state = VIR_DOMAIN_RUNNING; - } + + if (ret == 0) + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, reason); return ret; } -int qemuProcessStopCPUs(struct qemud_driver *driver, virDomainObjPtr vm) +int qemuProcessStopCPUs(struct qemud_driver *driver, virDomainObjPtr vm, + virDomainPausedReason reason) { int ret; - int oldState = vm->state; + int oldState; + int oldReason; qemuDomainObjPrivatePtr priv = vm->privateData; - vm->state = VIR_DOMAIN_PAUSED; + oldState = virDomainObjGetState(vm, &oldReason); + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, reason); + qemuDomainObjEnterMonitorWithDriver(driver, vm); ret = qemuMonitorStopCPUs(priv->mon); qemuDomainObjExitMonitorWithDriver(driver, vm); - if (ret < 0) { - vm->state = oldState; - } + + if (ret < 0) + virDomainObjSetState(vm, oldState, oldReason); + return ret; } @@ -2027,7 +2035,7 @@ error: /* We can't get the monitor back, so must kill the VM * to remove danger of it ending up running twice if * user tries to start it again later */ - qemuProcessStop(driver, obj, 0); + qemuProcessStop(driver, obj, 0, VIR_DOMAIN_SHUTOFF_FAILED); if (!obj->persistent) virDomainRemoveInactive(&driver->domains, obj); else @@ -2364,7 +2372,6 @@ int qemuProcessStart(virConnectPtr conn, if (migrateFrom) start_paused = true; - vm->state = start_paused ? VIR_DOMAIN_PAUSED : VIR_DOMAIN_RUNNING; if (ret == -1) /* The VM failed to start; tear filters before taps */ virDomainConfVMNWFilterTeardown(vm); @@ -2408,15 +2415,20 @@ int qemuProcessStart(virConnectPtr conn, if (!start_paused) { VIR_DEBUG0("Starting domain CPUs"); /* Allow the CPUS to start executing */ - if (qemuProcessStartCPUs(driver, vm, conn) < 0) { + if (qemuProcessStartCPUs(driver, vm, conn, + VIR_DOMAIN_RUNNING_BOOTED) < 0) { if (virGetLastError() == NULL) qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("resume operation failed")); goto cleanup; } + } else { + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, + migrateFrom ? + VIR_DOMAIN_PAUSED_MIGRATION : + VIR_DOMAIN_PAUSED_USER); } - VIR_DEBUG0("Writing domain status to disk"); if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0) goto cleanup; @@ -2434,7 +2446,7 @@ cleanup: qemuCapsFree(qemuCaps); virCommandFree(cmd); VIR_FORCE_CLOSE(logfile); - qemuProcessStop(driver, vm, 0); + qemuProcessStop(driver, vm, 0, VIR_DOMAIN_SHUTOFF_FAILED); return -1; } @@ -2442,7 +2454,8 @@ cleanup: void qemuProcessStop(struct qemud_driver *driver, virDomainObjPtr vm, - int migrated) + int migrated, + virDomainShutoffReason reason) { int ret; int retries = 0; @@ -2599,7 +2612,7 @@ retry: vm->pid = -1; vm->def->id = -1; - vm->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason); VIR_FREE(priv->vcpupids); priv->nvcpupids = 0; diff --git a/src/qemu/qemu_process.h b/src/qemu/qemu_process.h index f1ab599..40b386d 100644 --- a/src/qemu/qemu_process.h +++ b/src/qemu/qemu_process.h @@ -28,8 +28,13 @@ int qemuProcessPrepareMonitorChr(struct qemud_driver *driver, virDomainChrSourceDefPtr monConfig, const char *vm); -int qemuProcessStartCPUs(struct qemud_driver *driver, virDomainObjPtr vm, virConnectPtr conn); -int qemuProcessStopCPUs(struct qemud_driver *driver, virDomainObjPtr vm); +int qemuProcessStartCPUs(struct qemud_driver *driver, + virDomainObjPtr vm, + virConnectPtr conn, + virDomainRunningReason reason); +int qemuProcessStopCPUs(struct qemud_driver *driver, + virDomainObjPtr vm, + virDomainPausedReason reason); void qemuProcessAutostartAll(struct qemud_driver *driver); void qemuProcessReconnectAll(virConnectPtr conn, struct qemud_driver *driver); @@ -47,6 +52,7 @@ int qemuProcessStart(virConnectPtr conn, void qemuProcessStop(struct qemud_driver *driver, virDomainObjPtr vm, - int migrated); + int migrated, + virDomainShutoffReason reason); #endif /* __QEMU_PROCESS_H__ */ diff --git a/src/test/test_driver.c b/src/test/test_driver.c index 1641747..ebedaee 100644 --- a/src/test/test_driver.c +++ b/src/test/test_driver.c @@ -459,7 +459,8 @@ cleanup: static void testDomainShutdownState(virDomainPtr domain, - virDomainObjPtr privdom) + virDomainObjPtr privdom, + virDomainShutoffReason reason) { if (privdom->newDef) { virDomainDefFree(privdom->def); @@ -467,7 +468,7 @@ testDomainShutdownState(virDomainPtr domain, privdom->newDef = NULL; } - privdom->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(privdom, VIR_DOMAIN_SHUTOFF, reason); privdom->def->id = -1; if (domain) domain->id = -1; @@ -476,7 +477,8 @@ testDomainShutdownState(virDomainPtr domain, /* Set up domain runtime state */ static int testDomainStartState(virConnectPtr conn, - virDomainObjPtr dom) + virDomainObjPtr dom, + virDomainRunningReason reason) { testConnPtr privconn = conn->privateData; int ret = -1; @@ -484,7 +486,7 @@ testDomainStartState(virConnectPtr conn, if (testDomainUpdateVCPUs(conn, dom, dom->def->vcpus, 1) < 0) goto cleanup; - dom->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(dom, VIR_DOMAIN_RUNNING, reason); dom->def->id = privconn->nextDomID++; if (virDomainObjSetDefTransient(privconn->caps, dom, false) < 0) { @@ -494,7 +496,7 @@ testDomainStartState(virConnectPtr conn, ret = 0; cleanup: if (ret < 0) - testDomainShutdownState(NULL, dom); + testDomainShutdownState(NULL, dom, VIR_DOMAIN_SHUTOFF_FAILED); return ret; } @@ -565,7 +567,7 @@ static int testOpenDefault(virConnectPtr conn) { domdef = NULL; domobj->persistent = 1; - if (testDomainStartState(conn, domobj) < 0) { + if (testDomainStartState(conn, domobj, VIR_DOMAIN_RUNNING_BOOTED) < 0) { virDomainObjUnlock(domobj); goto error; } @@ -925,7 +927,7 @@ static int testOpenFromFile(virConnectPtr conn, } dom->persistent = 1; - if (testDomainStartState(conn, dom) < 0) { + if (testDomainStartState(conn, dom, VIR_DOMAIN_RUNNING_BOOTED) < 0) { virDomainObjUnlock(dom); goto error; } @@ -1327,7 +1329,7 @@ testDomainCreateXML(virConnectPtr conn, const char *xml, goto cleanup; def = NULL; - if (testDomainStartState(conn, dom) < 0) + if (testDomainStartState(conn, dom, VIR_DOMAIN_RUNNING_BOOTED) < 0) goto cleanup; event = virDomainEventNewFromObj(dom, @@ -1457,7 +1459,7 @@ static int testDestroyDomain (virDomainPtr domain) goto cleanup; } - testDomainShutdownState(domain, privdom); + testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_DESTROYED); event = virDomainEventNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_DESTROYED); @@ -1495,13 +1497,14 @@ static int testResumeDomain (virDomainPtr domain) goto cleanup; } - if (privdom->state != VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(privdom, NULL) != VIR_DOMAIN_PAUSED) { testError(VIR_ERR_INTERNAL_ERROR, _("domain '%s' not paused"), domain->name); goto cleanup; } - privdom->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(privdom, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_UNPAUSED); event = virDomainEventNewFromObj(privdom, VIR_DOMAIN_EVENT_RESUMED, VIR_DOMAIN_EVENT_RESUMED_UNPAUSED); @@ -1523,6 +1526,7 @@ static int testPauseDomain (virDomainPtr domain) testConnPtr privconn = domain->conn->privateData; virDomainObjPtr privdom; virDomainEventPtr event = NULL; + int state; int ret = -1; testDriverLock(privconn); @@ -1535,14 +1539,14 @@ static int testPauseDomain (virDomainPtr domain) goto cleanup; } - if (privdom->state == VIR_DOMAIN_SHUTOFF || - privdom->state == VIR_DOMAIN_PAUSED) { + state = virDomainObjGetState(privdom, NULL); + if (state == VIR_DOMAIN_SHUTOFF || state == VIR_DOMAIN_PAUSED) { testError(VIR_ERR_INTERNAL_ERROR, _("domain '%s' not running"), domain->name); goto cleanup; } - privdom->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(privdom, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); event = virDomainEventNewFromObj(privdom, VIR_DOMAIN_EVENT_SUSPENDED, VIR_DOMAIN_EVENT_SUSPENDED_PAUSED); @@ -1576,13 +1580,13 @@ static int testShutdownDomain (virDomainPtr domain) goto cleanup; } - if (privdom->state == VIR_DOMAIN_SHUTOFF) { + if (virDomainObjGetState(privdom, NULL) == VIR_DOMAIN_SHUTOFF) { testError(VIR_ERR_INTERNAL_ERROR, _("domain '%s' not running"), domain->name); goto cleanup; } - testDomainShutdownState(domain, privdom); + testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_SHUTDOWN); event = virDomainEventNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); @@ -1621,31 +1625,38 @@ static int testRebootDomain (virDomainPtr domain, goto cleanup; } - privdom->state = VIR_DOMAIN_SHUTDOWN; + virDomainObjSetState(privdom, VIR_DOMAIN_SHUTDOWN, + VIR_DOMAIN_SHUTDOWN_USER); + switch (privdom->def->onReboot) { case VIR_DOMAIN_LIFECYCLE_DESTROY: - privdom->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(privdom, VIR_DOMAIN_SHUTOFF, + VIR_DOMAIN_SHUTOFF_SHUTDOWN); break; case VIR_DOMAIN_LIFECYCLE_RESTART: - privdom->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(privdom, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_BOOTED); break; case VIR_DOMAIN_LIFECYCLE_PRESERVE: - privdom->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(privdom, VIR_DOMAIN_SHUTOFF, + VIR_DOMAIN_SHUTOFF_SHUTDOWN); break; case VIR_DOMAIN_LIFECYCLE_RESTART_RENAME: - privdom->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(privdom, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_BOOTED); break; default: - privdom->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(privdom, VIR_DOMAIN_SHUTOFF, + VIR_DOMAIN_SHUTOFF_SHUTDOWN); break; } - if (privdom->state == VIR_DOMAIN_SHUTOFF) { - testDomainShutdownState(domain, privdom); + if (virDomainObjGetState(privdom, NULL) == VIR_DOMAIN_SHUTOFF) { + testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_SHUTDOWN); event = virDomainEventNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); @@ -1691,7 +1702,7 @@ static int testGetDomainInfo (virDomainPtr domain, goto cleanup; } - info->state = privdom->state; + info->state = virDomainObjGetState(privdom, NULL); info->memory = privdom->def->mem.cur_balloon; info->maxMem = privdom->def->mem.max_balloon; info->nrVirtCpu = privdom->def->vcpus; @@ -1721,10 +1732,7 @@ testDomainGetState(virDomainPtr domain, int *state, int *reason) goto cleanup; } - *state = privdom->state; - if (reason) - *reason = 0; - + *state = virDomainObjGetState(privdom, reason); ret = 0; cleanup: @@ -1799,7 +1807,7 @@ static int testDomainSave(virDomainPtr domain, } fd = -1; - testDomainShutdownState(domain, privdom); + testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_SAVED); event = virDomainEventNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_SAVED); @@ -1897,7 +1905,7 @@ static int testDomainRestore(virConnectPtr conn, goto cleanup; def = NULL; - if (testDomainStartState(conn, dom) < 0) + if (testDomainStartState(conn, dom, VIR_DOMAIN_RUNNING_RESTORED) < 0) goto cleanup; event = virDomainEventNewFromObj(dom, @@ -1956,7 +1964,7 @@ static int testDomainCoreDump(virDomainPtr domain, } if (flags & VIR_DUMP_CRASH) { - testDomainShutdownState(domain, privdom); + testDomainShutdownState(domain, privdom, VIR_DOMAIN_SHUTOFF_CRASHED); event = virDomainEventNewFromObj(privdom, VIR_DOMAIN_EVENT_STOPPED, VIR_DOMAIN_EVENT_STOPPED_CRASHED); @@ -2509,13 +2517,14 @@ static int testDomainCreateWithFlags(virDomainPtr domain, unsigned int flags) { goto cleanup; } - if (privdom->state != VIR_DOMAIN_SHUTOFF) { + if (virDomainObjGetState(privdom, NULL) != VIR_DOMAIN_SHUTOFF) { testError(VIR_ERR_INTERNAL_ERROR, _("Domain '%s' is already running"), domain->name); goto cleanup; } - if (testDomainStartState(domain->conn, privdom) < 0) + if (testDomainStartState(domain->conn, privdom, + VIR_DOMAIN_RUNNING_BOOTED) < 0) goto cleanup; domain->id = privdom->def->id; @@ -2552,13 +2561,12 @@ static int testDomainUndefine(virDomainPtr domain) { goto cleanup; } - if (privdom->state != VIR_DOMAIN_SHUTOFF) { + if (virDomainObjGetState(privdom, NULL) != VIR_DOMAIN_SHUTOFF) { testError(VIR_ERR_INTERNAL_ERROR, _("Domain '%s' is still running"), domain->name); goto cleanup; } - privdom->state = VIR_DOMAIN_SHUTOFF; event = virDomainEventNewFromObj(privdom, VIR_DOMAIN_EVENT_UNDEFINED, VIR_DOMAIN_EVENT_UNDEFINED_REMOVED); diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c index cd659db..dca2cbe 100644 --- a/src/uml/uml_driver.c +++ b/src/uml/uml_driver.c @@ -133,7 +133,8 @@ static int umlStartVMDaemon(virConnectPtr conn, static void umlShutdownVMDaemon(virConnectPtr conn, struct uml_driver *driver, - virDomainObjPtr vm); + virDomainObjPtr vm, + virDomainShutoffReason reason); static int umlMonitorCommand(const struct uml_driver *driver, @@ -305,7 +306,7 @@ reread: continue; } - umlShutdownVMDaemon(NULL, driver, dom); + umlShutdownVMDaemon(NULL, driver, dom, VIR_DOMAIN_SHUTOFF_SHUTDOWN); } else if (e->mask & (IN_CREATE | IN_MODIFY)) { VIR_DEBUG("Got inotify domain startup '%s'", name); if (virDomainObjIsActive(dom)) { @@ -319,14 +320,17 @@ reread: } dom->def->id = driver->nextvmid++; - dom->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(dom, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_BOOTED); if (umlOpenMonitor(driver, dom) < 0) { VIR_WARN0("Could not open monitor for new domain"); - umlShutdownVMDaemon(NULL, driver, dom); + umlShutdownVMDaemon(NULL, driver, dom, + VIR_DOMAIN_SHUTOFF_FAILED); } else if (umlIdentifyChrPTY(driver, dom) < 0) { VIR_WARN0("Could not identify charater devices for new domain"); - umlShutdownVMDaemon(NULL, driver, dom); + umlShutdownVMDaemon(NULL, driver, dom, + VIR_DOMAIN_SHUTOFF_FAILED); } } virDomainObjUnlock(dom); @@ -515,7 +519,7 @@ umlShutdownOneVM(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque) virDomainObjLock(dom); if (virDomainObjIsActive(dom)) - umlShutdownVMDaemon(NULL, driver, dom); + umlShutdownVMDaemon(NULL, driver, dom, VIR_DOMAIN_SHUTOFF_SHUTDOWN); virDomainObjUnlock(dom); } @@ -907,7 +911,8 @@ cleanup: static void umlShutdownVMDaemon(virConnectPtr conn ATTRIBUTE_UNUSED, struct uml_driver *driver ATTRIBUTE_UNUSED, - virDomainObjPtr vm) + virDomainObjPtr vm, + virDomainShutoffReason reason) { int ret; umlDomainObjPrivatePtr priv = vm->privateData; @@ -926,7 +931,7 @@ static void umlShutdownVMDaemon(virConnectPtr conn ATTRIBUTE_UNUSED, vm->pid = -1; vm->def->id = -1; - vm->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason); virDomainConfVMNWFilterTeardown(vm); umlCleanupTapDevices(conn, vm); @@ -1345,7 +1350,7 @@ static int umlDomainDestroy(virDomainPtr dom) { goto cleanup; } - umlShutdownVMDaemon(dom->conn, driver, vm); + umlShutdownVMDaemon(dom->conn, driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED); if (!vm->persistent) { virDomainRemoveInactive(&driver->domains, vm); @@ -1498,7 +1503,7 @@ static int umlDomainGetInfo(virDomainPtr dom, goto cleanup; } - info->state = vm->state; + info->state = virDomainObjGetState(vm, NULL); if (!virDomainObjIsActive(vm)) { info->cpuTime = 0; @@ -1539,10 +1544,7 @@ umlDomainGetState(virDomainPtr dom, int *state, int *reason) goto cleanup; } - *state = vm->state; - if (reason) - *reason = 0; - + *state = virDomainObjGetState(vm, reason); ret = 0; cleanup: diff --git a/src/vmware/vmware_conf.c b/src/vmware/vmware_conf.c index 6339248..4ec33ae 100644 --- a/src/vmware/vmware_conf.c +++ b/src/vmware/vmware_conf.c @@ -185,7 +185,8 @@ vmwareLoadDomains(struct vmware_driver *driver) if ((vm->def->id = vmwareExtractPid(vmxPath)) < 0) goto cleanup; /* vmrun list only reports running vms */ - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, + VIR_DOMAIN_RUNNING_UNKNOWN); vm->persistent = 1; virDomainObjUnlock(vm); diff --git a/src/vmware/vmware_driver.c b/src/vmware/vmware_driver.c index 9b22d4a..8d0af46 100644 --- a/src/vmware/vmware_driver.c +++ b/src/vmware/vmware_driver.c @@ -178,7 +178,9 @@ vmwareGetVersion(virConnectPtr conn, unsigned long *version) } static int -vmwareStopVM(struct vmware_driver *driver, virDomainObjPtr vm) +vmwareStopVM(struct vmware_driver *driver, + virDomainObjPtr vm, + virDomainShutoffReason reason) { const char *cmd[] = { VMRUN, "-T", PROGRAM_SENTINAL, "stop", @@ -193,7 +195,7 @@ vmwareStopVM(struct vmware_driver *driver, virDomainObjPtr vm) } vm->def->id = -1; - vm->state = VIR_DOMAIN_SHUTOFF; + virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason); return 0; } @@ -207,7 +209,7 @@ vmwareStartVM(struct vmware_driver *driver, virDomainObjPtr vm) }; const char *vmxPath = ((vmwareDomainPtr) vm->privateData)->vmxPath; - if (vm->state != VIR_DOMAIN_SHUTOFF) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_SHUTOFF) { vmwareError(VIR_ERR_OPERATION_INVALID, "%s", _("domain is not in shutoff state")); return -1; @@ -225,11 +227,11 @@ vmwareStartVM(struct vmware_driver *driver, virDomainObjPtr vm) } if ((vm->def->id = vmwareExtractPid(vmxPath)) < 0) { - vmwareStopVM(driver, vm); + vmwareStopVM(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED); return -1; } - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_BOOTED); return 0; } @@ -322,13 +324,13 @@ vmwareDomainShutdown(virDomainPtr dom) goto cleanup; } - if (vm->state != VIR_DOMAIN_RUNNING) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) { vmwareError(VIR_ERR_INTERNAL_ERROR, "%s", _("domain is not in running state")); goto cleanup; } - if (vmwareStopVM(driver, vm) < 0) + if (vmwareStopVM(driver, vm, VIR_DOMAIN_SHUTOFF_SHUTDOWN) < 0) goto cleanup; if (!vm->persistent) { @@ -375,7 +377,7 @@ vmwareDomainSuspend(virDomainPtr dom) vmwareSetSentinal(cmd, vmw_types[driver->type]); vmwareSetSentinal(cmd, ((vmwareDomainPtr) vm->privateData)->vmxPath); - if (vm->state != VIR_DOMAIN_RUNNING) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) { vmwareError(VIR_ERR_INTERNAL_ERROR, "%s", _("domain is not in running state")); goto cleanup; @@ -384,7 +386,7 @@ vmwareDomainSuspend(virDomainPtr dom) if (virRun(cmd, NULL) < 0) goto cleanup; - vm->state = VIR_DOMAIN_PAUSED; + virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_USER); ret = 0; cleanup: @@ -424,7 +426,7 @@ vmwareDomainResume(virDomainPtr dom) vmwareSetSentinal(cmd, vmw_types[driver->type]); vmwareSetSentinal(cmd, ((vmwareDomainPtr) vm->privateData)->vmxPath); - if (vm->state != VIR_DOMAIN_PAUSED) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) { vmwareError(VIR_ERR_INTERNAL_ERROR, "%s", _("domain is not in suspend state")); goto cleanup; @@ -433,7 +435,7 @@ vmwareDomainResume(virDomainPtr dom) if (virRun(cmd, NULL) < 0) goto cleanup; - vm->state = VIR_DOMAIN_RUNNING; + virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, VIR_DOMAIN_RUNNING_UNPAUSED); ret = 0; cleanup: @@ -470,7 +472,7 @@ vmwareDomainReboot(virDomainPtr dom, unsigned int flags ATTRIBUTE_UNUSED) vmwareSetSentinal(cmd, vmxPath); - if (vm->state != VIR_DOMAIN_RUNNING) { + if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) { vmwareError(VIR_ERR_INTERNAL_ERROR, "%s", _("domain is not in running state")); goto cleanup; @@ -883,7 +885,7 @@ vmwareDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info) goto cleanup; } - info->state = vm->state; + info->state = virDomainObjGetState(vm, NULL); info->cpuTime = 0; info->maxMem = vm->def->mem.max_balloon; info->memory = vm->def->mem.cur_balloon; @@ -913,10 +915,7 @@ vmwareDomainGetState(virDomainPtr dom, int *state, int *reason) goto cleanup; } - *state = vm->state; - if (reason) - *reason = 0; - + *state = virDomainObjGetState(vm, reason); ret = 0; cleanup: -- 1.7.5.rc3