Add @seconds variable to qemuAgentSend(). When @tiemout is true, @seconds controls how long to wait for a response (if @seconds is VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT, default to QEMU_AGENT_WAIT_TIME). If @timeout is false, @seconds is ignored. Signed-off-by: MATSUDA Daiki <matsudadik(a)intellilink.co.jp&gt; --- include/libvirt/libvirt-qemu.h | 6 ++++++ src/qemu/qemu_agent.c | 30 ++++++++++++++++++++---------- 2 files changed, 26 insertions(+), 10 deletions(-) diff --git a/include/libvirt/libvirt-qemu.h b/include/libvirt/libvirt-qemu.h index a37f897..013ed5a 100644 --- a/include/libvirt/libvirt-qemu.h +++ b/include/libvirt/libvirt-qemu.h @@ -44,6 +44,12 @@ virDomainPtr virDomainQemuAttach(virConnectPtr domain, unsigned int pid_value, unsigned int flags); +typedef enum { + VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK = -2, + VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT = -1, + VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT = 0, +} virDomainQemuAgentCommandTimeoutValues; + # ifdef __cplusplus } # endif diff --git a/src/qemu/qemu_agent.c b/src/qemu/qemu_agent.c index 15af758..26c2726 100644 --- a/src/qemu/qemu_agent.c +++ b/src/qemu/qemu_agent.c @@ -837,6 +837,8 @@ void qemuAgentClose(qemuAgentPtr mon) * @mon: Monitor * @msg: Message * @timeout: use timeout? + * @seconds: timeout seconds. if VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT and + * @timeout is true, use default value. * * Send @msg to agent @mon. * Wait max QEMU_AGENT_WAIT_TIME for agent @@ -848,7 +850,8 @@ void qemuAgentClose(qemuAgentPtr mon) */ static int qemuAgentSend(qemuAgentPtr mon, qemuAgentMessagePtr msg, - bool timeout) + bool timeout, + int seconds) { int ret = -1; unsigned long long now, then = 0; @@ -864,7 +867,8 @@ static int qemuAgentSend(qemuAgentPtr mon, if (timeout) { if (virTimeMillisNow(&now) < 0) return -1; - then = now + QEMU_AGENT_WAIT_TIME; + then = now + (seconds == VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT ? + QEMU_AGENT_WAIT_TIME : seconds * 1000ull); } mon->msg = msg; @@ -937,7 +941,8 @@ qemuAgentGuestSync(qemuAgentPtr mon) VIR_DEBUG("Sending guest-sync command with ID: %llu", id); - send_ret = qemuAgentSend(mon, &sync_msg, true); + send_ret = qemuAgentSend(mon, &sync_msg, true, + VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT); VIR_DEBUG("qemuAgentSend returned: %d", send_ret); @@ -977,7 +982,8 @@ cleanup: static int qemuAgentCommand(qemuAgentPtr mon, virJSONValuePtr cmd, - virJSONValuePtr *reply) + virJSONValuePtr *reply, + int seconds) { int ret = -1; qemuAgentMessage msg; @@ -1003,9 +1009,9 @@ qemuAgentCommand(qemuAgentPtr mon, } msg.txLength = strlen(msg.txBuffer); - VIR_DEBUG("Send command '%s' for write", cmdstr); + VIR_DEBUG("Send command '%s' for write, seconds = %d", cmdstr, seconds); - ret = qemuAgentSend(mon, &msg, false); + ret = qemuAgentSend(mon, &msg, seconds < -1 ? false : true, seconds); VIR_DEBUG("Receive command reply ret=%d rxObject=%p", ret, msg.rxObject); @@ -1283,7 +1289,8 @@ int qemuAgentShutdown(qemuAgentPtr mon, return -1; mon->await_event = QEMU_AGENT_EVENT_SHUTDOWN; - ret = qemuAgentCommand(mon, cmd, &reply); + ret = qemuAgentCommand(mon, cmd, &reply, + VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT); if (reply && ret == 0) ret = qemuAgentCheckError(cmd, reply); @@ -1315,7 +1322,8 @@ int qemuAgentFSFreeze(qemuAgentPtr mon) if (!cmd) return -1; - if (qemuAgentCommand(mon, cmd, &reply) < 0 || + if (qemuAgentCommand(mon, cmd, &reply, + VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT) < 0 || qemuAgentCheckError(cmd, reply) < 0) goto cleanup; @@ -1352,7 +1360,8 @@ int qemuAgentFSThaw(qemuAgentPtr mon) if (!cmd) return -1; - if (qemuAgentCommand(mon, cmd, &reply) < 0 || + if (qemuAgentCommand(mon, cmd, &reply, + VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT) < 0 || qemuAgentCheckError(cmd, reply) < 0) goto cleanup; @@ -1389,7 +1398,8 @@ qemuAgentSuspend(qemuAgentPtr mon, return -1; mon->await_event = QEMU_AGENT_EVENT_SUSPEND; - ret = qemuAgentCommand(mon, cmd, &reply); + ret = qemuAgentCommand(mon, cmd, &reply, + VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT); if (reply && ret == 0) ret = qemuAgentCheckError(cmd, reply); -- 1.7.1

(2012/08/16 21:58), Martin Kletzander wrote: Yes, it is same that @timeout = false to qemuAgentSend() from qemuAgentCommand(). @seconds is effective uder the situation @timeout = true. Then @seconds must be > 0. But @seconds = 0, it is dangerous. I do not understand whether it is needed, but other people discussed. https://www.redhat.com/archives/libvir-list/2012-July/msg00603.html Its situation is blocked on calling qemuAgentSend() from qemuAgentCommand(). But qemuAgentSend() may also have the block code.

add qemuAgentArbitraryCommand() for general qemu agent command. Signed-off-by: MATSUDA Daiki <matsudadik(a)intellilink.co.jp&gt; --- src/qemu/qemu_agent.c | 31 +++++++++++++++++++++++++++++++ src/qemu/qemu_agent.h | 5 +++++ 2 files changed, 36 insertions(+), 0 deletions(-) diff --git a/src/qemu/qemu_agent.c b/src/qemu/qemu_agent.c index 26c2726..c634c23 100644 --- a/src/qemu/qemu_agent.c +++ b/src/qemu/qemu_agent.c @@ -1408,3 +1408,34 @@ qemuAgentSuspend(qemuAgentPtr mon, virJSONValueFree(reply); return ret; } + +int +qemuAgentArbitraryCommand(qemuAgentPtr mon, + const char *cmd_str, + char **result, + int timeout) +{ + int ret = -1; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + + if (timeout < -2) + return ret; + + cmd = virJSONValueFromString(cmd_str); + if (!cmd) + return ret; + + ret = qemuAgentCommand(mon, cmd, &reply, timeout); + + if (ret == 0) { + ret = qemuAgentCheckError(cmd, reply); + *result = virJSONValueToString(reply); + } else { + result = NULL; + } + + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} diff --git a/src/qemu/qemu_agent.h b/src/qemu/qemu_agent.h index 2fdebb2..528fee1 100644 --- a/src/qemu/qemu_agent.h +++ b/src/qemu/qemu_agent.h @@ -77,4 +77,9 @@ int qemuAgentFSThaw(qemuAgentPtr mon); int qemuAgentSuspend(qemuAgentPtr mon, unsigned int target); + +int qemuAgentArbitraryCommand(qemuAgentPtr mon, + const char *cmd, + char **result, + int timeout); #endif /* __QEMU_AGENT_H__ */ -- 1.7.1

Add virDrvAgentCommand prototype for drivers. Add virAgentCommand() for virDrvAgentCommand. Signed-off-by: MATSUDA Daiki <matsudadik(a)intellilink.co.jp&gt; --- include/libvirt/libvirt-qemu.h | 3 ++ python/generator.py | 1 + src/driver.h | 4 +++ src/libvirt-qemu.c | 51 ++++++++++++++++++++++++++++++++++++++++ src/libvirt_qemu.syms | 5 ++++ 5 files changed, 64 insertions(+), 0 deletions(-) diff --git a/include/libvirt/libvirt-qemu.h b/include/libvirt/libvirt-qemu.h index 013ed5a..60b83ef 100644 --- a/include/libvirt/libvirt-qemu.h +++ b/include/libvirt/libvirt-qemu.h @@ -50,6 +50,9 @@ typedef enum { VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT = 0, } virDomainQemuAgentCommandTimeoutValues; +char *virAgentCommand(virDomainPtr domain, const char *cmd, + int timeout, unsigned int flags); + # ifdef __cplusplus } # endif diff --git a/python/generator.py b/python/generator.py index 6559ece..68758ad 100755 --- a/python/generator.py +++ b/python/generator.py @@ -431,6 +431,7 @@ skip_impl = ( qemu_skip_impl = ( 'virDomainQemuMonitorCommand', + 'virAgentCommand', ) diff --git a/src/driver.h b/src/driver.h index aab9766..b780e45 100644 --- a/src/driver.h +++ b/src/driver.h @@ -688,6 +688,9 @@ typedef int typedef int (*virDrvDomainQemuMonitorCommand)(virDomainPtr domain, const char *cmd, char **result, unsigned int flags); +typedef char * + (*virDrvAgentCommand)(virDomainPtr domain, const char *cmd, + int timeout, unsigned int flags); /* Choice of unsigned int rather than pid_t is intentional. */ typedef virDomainPtr @@ -1048,6 +1051,7 @@ struct _virDriver { virDrvDomainGetDiskErrors domainGetDiskErrors; virDrvDomainSetMetadata domainSetMetadata; virDrvDomainGetMetadata domainGetMetadata; + virDrvAgentCommand qemuAgentCommand; }; typedef int diff --git a/src/libvirt-qemu.c b/src/libvirt-qemu.c index 78480bb..49dfc20 100644 --- a/src/libvirt-qemu.c +++ b/src/libvirt-qemu.c @@ -185,3 +185,54 @@ error: virDispatchError(conn); return NULL; } + +/** + * virAgentCommand: + * @domain: a domain object + * @cmd: the guest agent command string + * @timeout: timeout seconds + * @flags: execution flags + * + * Execute an arbitrary Guest Agent command. + * + * Issue @cmd to the guest agent running in @domain. + * If @result is NULL, then don't wait for a result (and @timeout + * must be 0). Otherwise, wait for @timeout seconds for a + * @timeout must be -2, -1, 0 or positive. + * VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK(-2): meaning to block forever waiting for + * a result. + * VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT(-1): use default timeout value. + * VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT(0): does not wait. + * positive value: wait for @timeout seconds + * + * Returns strings if success, NULL in failure. + */ +char * +virAgentCommand(virDomainPtr domain, + const char *cmd, + int timeout, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DEBUG("domain=%p, cmd=%s, timeout=%d, flags=%x", + domain, cmd, timeout, flags); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return NULL; + } + + conn = domain->conn; + + if (conn->driver->qemuAgentCommand) { + return conn->driver->qemuAgentCommand(domain, cmd, timeout, flags); + } + + virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); + + /* Copy to connection error object for back compatability */ + virDispatchError(domain->conn); + return NULL; +} diff --git a/src/libvirt_qemu.syms b/src/libvirt_qemu.syms index 8447730..f1a4bb4 100644 --- a/src/libvirt_qemu.syms +++ b/src/libvirt_qemu.syms @@ -19,3 +19,8 @@ LIBVIRT_QEMU_0.9.4 { global: virDomainQemuAttach; } LIBVIRT_QEMU_0.8.3; + +LIBVIRT_QEMU_0.10.0 { + global: + virAgentCommand; +} LIBVIRT_QEMU_0.9.4; -- 1.7.1

(2012/08/16 22:13), Martin Kletzander wrote: It depends on generating the code automatically Eric suggested. It decides the returning type. It is my mistake. I do not uderstand what you say.

Add qemuDomainAgentCommand() for .qemuAgentCommand to qemu driver. Signed-off-by: MATSUDA Daiki <matsudadik(a)intellilink.co.jp&gt; --- src/qemu/qemu_driver.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 71 insertions(+), 0 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index dee1268..36a698b 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -13204,6 +13204,76 @@ qemuListAllDomains(virConnectPtr conn, return ret; } +static char * +qemuDomainAgentCommand(virDomainPtr domain, + const char *cmd, + int timeout, + unsigned int flags) +{ + struct qemud_driver *driver = domain->conn->privateData; + virDomainObjPtr vm; + int ret = -1; + char *result = NULL; + qemuDomainObjPrivatePtr priv; + + virCheckFlags(0, NULL); + + qemuDriverLock(driver); + vm = virDomainFindByUUID(&driver->domains, domain->uuid); + qemuDriverUnlock(driver); + + if (!vm) { + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virUUIDFormat(domain->uuid, uuidstr); + virReportError(VIR_ERR_NO_DOMAIN, + _("no domain with matching uuid '%s'"), uuidstr); + goto cleanup; + } + + priv = vm->privateData; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto cleanup; + } + + if (priv->agentError) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("QEMU guest agent is not available due to an error")); + goto cleanup; + } + + if (!priv->agent) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("QEMU guest agent is not configured")); + goto cleanup; + } + + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) + goto cleanup; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto endjob; + } + + qemuDomainObjEnterAgent(driver, vm); + ret = qemuAgentArbitraryCommand(priv->agent, cmd, &result, timeout); + qemuDomainObjExitAgent(driver, vm); + +endjob: + if (qemuDomainObjEndJob(driver, vm) == 0) { + vm = NULL; + } + +cleanup: + if (vm) + virDomainObjUnlock(vm); + return result; +} + static virDriver qemuDriver = { .no = VIR_DRV_QEMU, .name = QEMU_DRIVER_NAME, @@ -13369,6 +13439,7 @@ static virDriver qemuDriver = { .domainPMSuspendForDuration = qemuDomainPMSuspendForDuration, /* 0.9.11 */ .domainPMWakeup = qemuDomainPMWakeup, /* 0.9.11 */ .domainGetCPUStats = qemuDomainGetCPUStats, /* 0.9.11 */ + .qemuAgentCommand = qemuDomainAgentCommand, /* 0.10.0 */ }; -- 1.7.1

On 08/15/2012 03:36 AM, MATSUDA Daiki wrote: You probably want to call some function like 'remoteQemuDomainAgentCommand' or something like that since qemuAgentCommand works locally and not remotely. I haven't had a look at the rest of the series. Please feel free to correct me in case I've misunderstood the code somewhere. Martin

On 08/20/2012 02:20 AM, MATSUDA, Daiki wrote: My concern wasn't about the function name. The problem is that there is no remote call. The function you are assigning here operates on local machine and not on the connected daemon side (there is no 'call()' in the stack). OTOH I haven't wrote an API myself, so I'm not in the right position to comment on this with a lot of self-confidence (I just took an inspiration out of other commands, mainly qemuMonitor*), so others opinions are welcomed. Martin

Add qemu-agent-command to virsh to support virAgentCommand(). Signed-off-by: MATSUDA Daiki <matsudadik(a)intellilink.co.jp&gt; --- tools/virsh-host.c | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++++ tools/virsh.pod | 13 +++++++ 2 files changed, 102 insertions(+), 0 deletions(-) diff --git a/tools/virsh-host.c b/tools/virsh-host.c index d9d09b4..d302e19 100644 --- a/tools/virsh-host.c +++ b/tools/virsh-host.c @@ -633,6 +633,93 @@ cleanup: } /* + * "qemu-agent-command" command + */ +static const vshCmdInfo info_qemu_agent_command[] = { + {"help", N_("QEMU Guest Agent Command")}, + {"desc", N_("Run an arbitrary qemu guest agent command; use at your own risk")}, + {NULL, NULL} +}; + +static const vshCmdOptDef opts_qemu_agent_command[] = { + {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")}, + {"timeout", VSH_OT_INT, VSH_OFLAG_REQ_OPT, N_("timeout seconds. must be positive.")}, + {"async", VSH_OT_BOOL, 0, N_("execute command without waiting for timeout")}, + {"block", VSH_OT_BOOL, 0, N_("execute command without timeout")}, + {"cmd", VSH_OT_ARGV, VSH_OFLAG_REQ, N_("command")}, + {NULL, 0, 0, NULL} +}; + +static bool +cmdQemuAgentCommand(vshControl *ctl, const vshCmd *cmd) +{ + virDomainPtr dom = NULL; + bool ret = false; + char *guest_agent_cmd = NULL; + char *result = NULL; + int timeout = VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT; + int judge = 0; + unsigned int flags = 0; + const vshCmdOpt *opt = NULL; + virBuffer buf = VIR_BUFFER_INITIALIZER; + bool pad = false; + + if (!vshConnectionUsability(ctl, ctl->conn)) + goto cleanup; + + dom = vshCommandOptDomain(ctl, cmd, NULL); + if (dom == NULL) + goto cleanup; + + while ((opt = vshCommandOptArgv(cmd, opt))) { + if (pad) + virBufferAddChar(&buf, ' '); + pad = true; + virBufferAdd(&buf, opt->data, -1); + } + if (virBufferError(&buf)) { + vshPrint(ctl, "%s", _("Failed to collect command")); + goto cleanup; + } + guest_agent_cmd = virBufferContentAndReset(&buf); + + judge = vshCommandOptInt(cmd, "timeout", &timeout); + if (judge < 0) { + vshError(ctl, "%s", _("timeout number has to be a number")); + } else if (judge > 0) { + judge = 1; + } + if (judge && timeout < 1) { + vshError(ctl, "%s", _("timeout must be positive")); + } + + if (vshCommandOptBool(cmd, "async")) { + timeout = VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT; + judge++; + } + if (vshCommandOptBool(cmd, "block")) { + timeout = VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK; + judge++; + } + + if (judge > 1) { + vshError(ctl, "%s", _("timeout, async and block options are exclusive")); + } + result = virAgentCommand(dom, guest_agent_cmd, timeout, flags); + + if (result) printf("%s\n", result); + + ret = true; + +cleanup: + VIR_FREE(result); + VIR_FREE(guest_agent_cmd); + if (dom) + virDomainFree(dom); + + return ret; +} +/* * "sysinfo" command */ static const vshCmdInfo info_sysinfo[] = { @@ -832,6 +919,8 @@ static const vshCmdDef hostAndHypervisorCmds[] = { {"qemu-attach", cmdQemuAttach, opts_qemu_attach, info_qemu_attach, 0}, {"qemu-monitor-command", cmdQemuMonitorCommand, opts_qemu_monitor_command, info_qemu_monitor_command, 0}, + {"qemu-agent-command", cmdQemuAgentCommand, opts_qemu_agent_command, + info_qemu_agent_command, 0}, {"sysinfo", cmdSysinfo, NULL, info_sysinfo, 0}, {"uri", cmdURI, NULL, info_uri, 0}, {"version", cmdVersion, opts_version, info_version, 0}, diff --git a/tools/virsh.pod b/tools/virsh.pod index 35613c4..f997cb4 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -164,6 +164,7 @@ group as an option. For example: hostname print the hypervisor hostname qemu-attach Attach to existing QEMU process qemu-monitor-command QEMU Monitor Command + qemu-agent-command QEMU Guest Agent Command sysinfo print the hypervisor sysinfo uri print the hypervisor canonical URI @@ -2780,6 +2781,18 @@ before passing the single command to the monitor. =back +=item B<qemu-agent-command> I<domain> [I<--timeout> I<seconds> | I<--async> | I<--block>] I<command>... + +Send an arbitrary guest agent command I<command> to domain I<domain> through +qemu agent. +I<--timeout>, I<--async> and I<--block> options are exclusive. +I<--timeout> requires timeout seconds I<seconds> and it must be positive. +When I<--aysnc> is given, the command waits for timeout whether success or +failed. And when I<--block> is given, the command waits forever with blocking +timeout. + +=back + =head1 ENVIRONMENT The following environment variables can be set to alter the behaviour -- 1.7.1