fixup

Signed-off-by: Michal Privoznik <mprivozn@redhat.com>

include/libvirt/libvirt-domain.h

@@ -4921,6 +4921,7 @@ typedef enum {
     VIR_DOMAIN_AGENT_COMMAND_DEFAULT = -1,
     VIR_DOMAIN_AGENT_COMMAND_NOWAIT = 0,
 } virDomainAgentCommandTimeoutValues;
+
 int virDomainAgentSetResponseTimeout(virDomainPtr domain,
                                      int timeout,
                                      unsigned int flags);

src/libvirt-domain.c

@@ -12498,21 +12498,23 @@ int virDomainGetLaunchSecurityInfo(virDomainPtr domain,
     return -1;
 }
 
+
 /**
  * virDomainAgentSetResponseTimeout:
  * @domain: a domain object
  * @timeout: timeout in seconds
  * @flags: extra flags; not used yet, so callers should always pass 0
  *
- * Set how long to wait for a response from qemu agent commands. By default,
+ * Set how long to wait for a response from QEMU agent commands. By default,
  * agent commands block forever waiting for a response.
  *
- * @timeout must be -2, -1, 0 or positive.
- * VIR_DOMAIN_AGENT_COMMAND_BLOCK(-2): meaning to block forever waiting for a
- * result.
- * VIR_DOMAIN_AGENT_COMMAND_DEFAULT(-1): use default timeout value.
- * VIR_DOMAIN_AGENT_COMMAND_NOWAIT(0): does not wait.
- * positive value: wait for @timeout seconds
+ * @timeout must be a value from virDomainAgentCommandTimeoutValues or
+ * positive:
+ *
+ *   VIR_DOMAIN_AGENT_COMMAND_BLOCK(-2): meaning to block forever waiting for a result.
+ *   VIR_DOMAIN_AGENT_COMMAND_DEFAULT(-1): use default timeout value.
+ *   VIR_DOMAIN_AGENT_COMMAND_NOWAIT(0): does not wait.
+ *   positive value: wait for @timeout seconds
  *
  * Returns 0 on success, -1 on failure
  */
@@ -12522,6 +12524,7 @@ virDomainAgentSetResponseTimeout(virDomainPtr domain,
                                  unsigned int flags)
 {
     virConnectPtr conn;
+
     VIR_DOMAIN_DEBUG(domain, "timeout=%i, flags=0x%x",
                      timeout, flags);
 

src/libvirt_public.syms

@@ -859,7 +859,10 @@ LIBVIRT_5.7.0 {
 
 LIBVIRT_5.8.0 {
         virConnectSetIdentity;
-        virDomainAgentSetResponseTimeout;
 } LIBVIRT_5.7.0;
 
+LIBVIRT_5.10.0 {
+        virDomainAgentSetResponseTimeout;
+} LIBVIRT_5.8.0;
+
 # .... define new API here using predicted next version number ....

src/qemu/qemu_agent.c

@@ -30,6 +30,7 @@
 #include <sys/time.h>
 
 #include "qemu_agent.h"
+#include "qemu_domain.h"
 #include "viralloc.h"
 #include "virlog.h"
 #include "virerror.h"
@@ -697,7 +698,7 @@ qemuAgentOpen(virDomainObjPtr vm,
         return NULL;
 
     /* agent commands block by default, user can choose different behavior */
-    mon->timeout = VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK;
+    mon->timeout = QEMU_DOMAIN_PRIVATE(vm)->agentTimeout;
     mon->fd = -1;
     if (virCondInit(&mon->notify) < 0) {
         virReportSystemError(errno, "%s",
@@ -2728,8 +2729,7 @@ qemuAgentGetTimezone(qemuAgentPtr mon,
  */
 int
 qemuAgentSetResponseTimeout(qemuAgentPtr mon,
-                            int timeout,
-                            unsigned int flags G_GNUC_UNUSED)
+                            int timeout)
 {
     if (timeout < VIR_DOMAIN_QEMU_AGENT_COMMAND_MIN) {
         virReportError(VIR_ERR_INVALID_ARG,

src/qemu/qemu_agent.h

@@ -142,5 +142,4 @@ int qemuAgentGetTimezone(qemuAgentPtr mon,
                          int *maxparams);
 
 int qemuAgentSetResponseTimeout(qemuAgentPtr mon,
-                                int timeout,
-                                unsigned int flags);
+                                int timeout);

src/qemu/qemu_domain.c

@@ -2102,6 +2102,7 @@ qemuDomainObjPrivateAlloc(void *opaque)
     if (!(priv->dbusVMStates = virHashCreate(5, dbusVMStateHashFree)))
         goto error;
 
+    priv->agentTimeout = VIR_DOMAIN_AGENT_COMMAND_DEFAULT;
     priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
     priv->driver = opaque;
 
@@ -15601,18 +15602,3 @@ qemuDomainSupportsCheckpointsBlockjobs(virDomainObjPtr vm)
 
     return 0;
 }
-
-int qemuDomainObjSetAgentResponseTimeout(virDomainObjPtr vm,
-                                         int timeout,
-                                         unsigned int flags)
-{
-    qemuDomainObjPrivatePtr priv = vm->privateData;
-    qemuAgentPtr agent = priv->agent;
-    int ret;
-
-    virObjectLock(agent);
-    ret = qemuAgentSetResponseTimeout(agent, timeout, flags);
-    virObjectUnlock(agent);
-
-    return ret;
-}

src/qemu/qemu_domain.h

@@ -293,6 +293,7 @@ struct _qemuDomainObjPrivate {
     virDomainChrSourceDefPtr monConfig;
     bool monError;
     unsigned long long monStart;
+    int agentTimeout;
 
     qemuAgentPtr agent;
     bool agentError;

src/qemu/qemu_driver.c

@@ -22654,27 +22654,66 @@ qemuDomainGetGuestInfo(virDomainPtr dom,
     return ret;
 }
 
+
 static int
 qemuDomainAgentSetResponseTimeout(virDomainPtr dom,
                                   int timeout,
                                   unsigned int flags)
 {
+    virQEMUDriverPtr driver = dom->conn->privateData;
     virDomainObjPtr vm = NULL;
+    qemuDomainAgentJob agentJob = QEMU_AGENT_JOB_NONE;
     int ret = -1;
 
+    virCheckFlags(0, -1);
+
     if (!(vm = qemuDomainObjFromDomain(dom)))
-        goto cleanup;
+        return -1;
 
     if (virDomainAgentSetResponseTimeoutEnsureACL(dom->conn, vm->def) < 0)
         goto cleanup;
 
-    ret = qemuDomainObjSetAgentResponseTimeout(vm, timeout, flags);
+    /* If domain has an agent, change it's timeout too. Otherwise
+     * just note down the request so that if agent appears it
+     * gets the requested timeout from the beginning. */
+    if (qemuDomainAgentAvailable(vm, false))
+        agentJob = QEMU_AGENT_JOB_MODIFY;
+
+    if (qemuDomainObjBeginJobWithAgent(driver, vm,
+                                       QEMU_JOB_MODIFY,
+                                       agentJob) < 0)
+        goto cleanup;
+
+    if (agentJob != QEMU_AGENT_JOB_NONE) {
+        qemuAgentPtr agent;
+        int rc;
+
+        if (virDomainObjCheckActive(vm) < 0)
+            goto endjob;
+
+        agent = qemuDomainObjEnterAgent(vm);
+        rc = qemuAgentSetResponseTimeout(agent, timeout);
+        qemuDomainObjExitAgent(vm, agent);
+
+        if (rc < 0)
+            goto endjob;
+    }
+
+    QEMU_DOMAIN_PRIVATE(vm)->agentTimeout = timeout;
+    ret = 0;
+
+ endjob:
+    if (agentJob != QEMU_AGENT_JOB_NONE)
+        qemuDomainObjEndJobWithAgent(driver, vm);
+    else
+        qemuDomainObjEndJob(driver, vm);
 
  cleanup:
     virDomainObjEndAPI(&vm);
     return ret;
 }
 
+
 static virHypervisorDriver qemuHypervisorDriver = {
     .name = QEMU_DRIVER_NAME,
     .connectURIProbe = qemuConnectURIProbe,
@@ -22911,7 +22950,7 @@ static virHypervisorDriver qemuHypervisorDriver = {
     .domainCheckpointGetParent = qemuDomainCheckpointGetParent, /* 5.6.0 */
     .domainCheckpointDelete = qemuDomainCheckpointDelete, /* 5.6.0 */
     .domainGetGuestInfo = qemuDomainGetGuestInfo, /* 5.7.0 */
-    .domainAgentSetResponseTimeout = qemuDomainAgentSetResponseTimeout, /* 5.8.0 */
+    .domainAgentSetResponseTimeout = qemuDomainAgentSetResponseTimeout, /* 5.10.0 */
 };
 
 

src/remote/remote_driver.c

@@ -8710,7 +8710,7 @@ static virHypervisorDriver hypervisor_driver = {
     .domainCheckpointGetParent = remoteDomainCheckpointGetParent, /* 5.6.0 */
     .domainCheckpointDelete = remoteDomainCheckpointDelete, /* 5.6.0 */
     .domainGetGuestInfo = remoteDomainGetGuestInfo, /* 5.7.0 */
-    .domainAgentSetResponseTimeout = remoteDomainAgentSetResponseTimeout, /* 5.8.0 */
+    .domainAgentSetResponseTimeout = remoteDomainAgentSetResponseTimeout, /* 5.10.0 */
 };
 
 static virNetworkDriver network_driver = {

tools/virsh-domain.c

@@ -9850,6 +9850,52 @@ cmdQemuAgentCommand(vshControl *ctl, const vshCmd *cmd)
 
     return ret;
 }
+/*
+ * "qemu-agent-timeout" command
+ */
+static const vshCmdInfo info_qemu_agent_timeout[] = {
+    {.name = "help",
+     .data = N_("QEMU Guest Agent Command")
+    },
+    {.name = "desc",
+     .data = N_("Run an arbitrary qemu guest agent command; use at your own risk")
+    },
+    {.name = NULL}
+};
+
+static const vshCmdOptDef opts_qemu_agent_timeout[] = {
+    VIRSH_COMMON_OPT_DOMAIN_FULL(0),
+    {.name = "timeout",
+     .type = VSH_OT_INT,
+     .flags = VSH_OFLAG_REQ_OPT,
+     .help = N_("timeout seconds.")
+    },
+    {.name = NULL}
+};
+
+static bool
+cmdQemuAgentTimeout(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom = NULL;
+    int timeout;
+    const unsigned int flags = 0;
+    bool ret = false;
+
+    dom = virshCommandOptDomain(ctl, cmd, NULL);
+    if (dom == NULL)
+        goto cleanup;
+
+    if (vshCommandOptInt(ctl, cmd, "timeout", &timeout) < 0)
+        goto cleanup;
+
+    if (virDomainAgentSetResponseTimeout(dom, timeout, flags) < 0)
+        goto cleanup;
+
+    ret = true;
+ cleanup:
+    virshDomainFree(dom);
+    return ret;
+}
 
 /*
  * "lxc-enter-namespace" namespace
@@ -14517,6 +14563,12 @@ const vshCmdDef domManagementCmds[] = {
      .info = info_qemu_agent_command,
      .flags = 0
     },
+    {.name = "qemu-agent-timeout",
+     .handler = cmdQemuAgentTimeout,
+     .opts = opts_qemu_agent_timeout,
+     .info = info_qemu_agent_timeout,
+     .flags = 0
+    },
     {.name = "reboot",
      .handler = cmdReboot,
      .opts = opts_reboot,