From: Chun Feng Wu <wucf@linux.ibm.com>
Support throttlegroup lifecycle management by the following implementation:
* New methods defined in "include/libvirt/libvirt-domain.h"
* And they're exported in "src/libvirt_public.syms"
* Corresponding internal API is defined in "src/driver-hypervisor.h"
* Public API calls are implemented in "src/libvirt-domain.c"
* Wire protocol is defined in "src/remote/remote_protocol.x"
* RPC client implementation is in "src/remote/remote_driver.c"
* Server side dispatch is implemented in "src/remote/remote_daemon_dispatch.c"
* Also "src/remote_protocol-structs" is updated
* Yu Jie Gu <guyujie@linux.ibm.com> helped add
remote_domain_set_throttle_group_args in src/remote_protocol-structs
to fix issue reported by check-remote_protocol
Signed-off-by: Chun Feng Wu <wucf@linux.ibm.com>
---
include/libvirt/libvirt-domain.h | 29 +++++
src/driver-hypervisor.h | 22 ++++
src/libvirt-domain.c | 190 ++++++++++++++++++++++++++++
src/libvirt_private.syms | 9 ++
src/libvirt_public.syms | 7 +
src/remote/remote_daemon_dispatch.c | 61 +++++++++
src/remote/remote_driver.c | 49 +++++++
src/remote/remote_protocol.x | 50 +++++++-
src/remote_protocol-structs | 30 +++++
9 files changed, 446 insertions(+), 1 deletion(-)
diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index 2f5b01bbfe..5435ab7fcb 100644
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -5593,6 +5593,16 @@ typedef void (*virConnectDomainEventJobCompletedCallback)(virConnectPtr conn,
*/
# define VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC_MAX_LENGTH "blkdeviotune.write_iops_sec_max_length"
+/**
+ * VIR_DOMAIN_THROTTLE_GROUP:
+ *
+ * Macro represents the name of throttle group for which the values are updated,
+ * as VIR_TYPED_PARAM_STRING.
+ *
+ * Since: 10.3.0
+ */
+# define VIR_DOMAIN_THROTTLE_GROUP "throttlegroup.name"
+
/**
* virConnectDomainEventTunableCallback:
* @conn: connection object
@@ -6525,4 +6535,23 @@ virDomainGraphicsReload(virDomainPtr domain,
unsigned int type,
unsigned int flags);
+int
+virDomainSetThrottleGroup(virDomainPtr dom,
+ const char *group,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags);
+int
+virDomainGetThrottleGroup(virDomainPtr dom,
+ const char *group,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags);
+
+int
+virDomainDelThrottleGroup(virDomainPtr dom,
+ const char *group,
+ unsigned int flags);
+
+
#endif /* LIBVIRT_DOMAIN_H */
diff --git a/src/driver-hypervisor.h b/src/driver-hypervisor.h
index 4ce8da078d..2c81fc8ad6 100644
--- a/src/driver-hypervisor.h
+++ b/src/driver-hypervisor.h
@@ -1453,6 +1453,25 @@ typedef int
unsigned int type,
unsigned int flags);
+typedef int
+(*virDrvDomainSetThrottleGroup)(virDomainPtr dom,
+ const char *groupname,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags);
+
+typedef int
+(*virDrvDomainGetThrottleGroup)(virDomainPtr dom,
+ const char *groupname,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags);
+
+typedef int
+(*virDrvDomainDelThrottleGroup)(virDomainPtr dom,
+ const char *groupname,
+ unsigned int flags);
+
typedef struct _virHypervisorDriver virHypervisorDriver;
/**
@@ -1726,4 +1745,7 @@ struct _virHypervisorDriver {
virDrvDomainStartDirtyRateCalc domainStartDirtyRateCalc;
virDrvDomainFDAssociate domainFDAssociate;
virDrvDomainGraphicsReload domainGraphicsReload;
+ virDrvDomainSetThrottleGroup domainSetThrottleGroup;
+ virDrvDomainGetThrottleGroup domainGetThrottleGroup;
+ virDrvDomainDelThrottleGroup domainDelThrottleGroup;
};
diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c
index 7c6b93963c..da88457601 100644
--- a/src/libvirt-domain.c
+++ b/src/libvirt-domain.c
@@ -14162,3 +14162,193 @@ virDomainGraphicsReload(virDomainPtr domain,
virDispatchError(domain->conn);
return -1;
}
+
+
+/**
+ * virDomainSetThrottleGroup:
+ * @dom: pointer to domain object
+ * @group: throttle group name
+ * @params: Pointer to blkio parameter objects
+ * @nparams: Number of blkio parameters (this value can be the same or
+ * less than the number of parameters supported)
+ * @flags: bitwise-OR of virDomainModificationImpact
+ *
+ * add or change throttle group.
+ *
+ *
+ * Returns -1 in case of error, 0 in case of success.
+ *
+ * Since: 10.3.0
+ */
+int
+virDomainSetThrottleGroup(virDomainPtr dom,
+ const char *group,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+
+ VIR_DOMAIN_DEBUG(dom, "params=%p, nparams=%d, flags=0x%x",
+ params, nparams, flags);
+ VIR_TYPED_PARAMS_DEBUG(params, nparams);
+
+ virResetLastError();
+
+ virCheckDomainReturn(dom, -1);
+ conn = dom->conn;
+
+ virCheckReadOnlyGoto(conn->flags, error);
+ virCheckPositiveArgGoto(nparams, error);
+ virCheckNonNullArgGoto(params, error);
+
+ if (virTypedParameterValidateSet(dom->conn, params, nparams) < 0)
+ goto error;
+
+ if (conn->driver->domainSetThrottleGroup) {
+ int ret;
+ ret = conn->driver->domainSetThrottleGroup(dom, group, params, nparams, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(dom->conn);
+ return -1;
+}
+
+
+/**
+ * virDomainGetThrottleGroup:
+ * @dom: pointer to domain object
+ * @group: throttle group name
+ * @params: Pointer to blkio parameter object
+ * (return value, allocated by the caller)
+ * @nparams: Pointer to number of blkio parameters
+ * @flags: bitwise-OR of virDomainModificationImpact and virTypedParameterFlags
+ *
+ * Get all parameters for specific throttle group. On input,
+ * @nparams gives the size of the @params array; on output, @nparams
+ * gives how many slots were filled with parameter information, which
+ * might be less but will not exceed the input value.
+ *
+ * As a special case, calling with @params as NULL and @nparams as 0
+ * on input will cause @nparams on output to contain the number of
+ * parameters supported by the hypervisor, either for the given @group
+ * or if @group is NULL, for all possible groups. The
+ * caller should then allocate @params array,
+ * i.e. (sizeof(@virTypedParameter) * @nparams) bytes and call the API
+ * again. See virDomainGetMemoryParameters() for more details.
+ *
+ *
+ * Returns -1 in case of error, 0 in case of success.
+ *
+ * Since: 10.3.0
+ */
+int
+virDomainGetThrottleGroup(virDomainPtr dom,
+ const char *group,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+ int rc;
+
+ VIR_DOMAIN_DEBUG(dom, "params=%p, nparams=%d, flags=0x%x",
+ params, (nparams) ? *nparams : -1, flags);
+
+ virResetLastError();
+
+ virCheckDomainReturn(dom, -1);
+
+ virCheckNonNullArgGoto(nparams, error);
+ virCheckNonNegativeArgGoto(*nparams, error);
+ if (*nparams != 0) {
+ virCheckNonNullArgGoto(params, error);
+ virCheckNonNullArgGoto(group, error);
+ }
+
+ rc = VIR_DRV_SUPPORTS_FEATURE(dom->conn->driver, dom->conn,
+ VIR_DRV_FEATURE_TYPED_PARAM_STRING);
+ if (rc < 0)
+ goto error;
+ if (rc)
+ flags |= VIR_TYPED_PARAM_STRING_OKAY;
+
+ VIR_EXCLUSIVE_FLAGS_GOTO(VIR_DOMAIN_AFFECT_LIVE,
+ VIR_DOMAIN_AFFECT_CONFIG,
+ error);
+
+ conn = dom->conn;
+
+ if (conn->driver->domainGetThrottleGroup) {
+ int ret;
+ ret = conn->driver->domainGetThrottleGroup(dom, group, params, nparams, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(dom->conn);
+ return -1;
+}
+
+
+/**
+ * virDomainDelThrottleGroup:
+ * @dom: pointer to domain object
+ * @group: throttle group name
+ * @flags: bitwise-OR of virDomainModificationImpact and virTypedParameterFlags
+ *
+ * Delete specific throttle group
+ *
+ * Returns -1 in case of error, 0 in case of success.
+ *
+ * Since: 10.3.0
+ */
+int
+virDomainDelThrottleGroup(virDomainPtr dom,
+ const char *group,
+ unsigned int flags)
+{
+ virConnectPtr conn;
+ int rc;
+
+ virResetLastError();
+
+ virCheckDomainReturn(dom, -1);
+
+ rc = VIR_DRV_SUPPORTS_FEATURE(dom->conn->driver, dom->conn,
+ VIR_DRV_FEATURE_TYPED_PARAM_STRING);
+ if (rc < 0)
+ goto error;
+ if (rc)
+ flags |= VIR_TYPED_PARAM_STRING_OKAY;
+
+ VIR_EXCLUSIVE_FLAGS_GOTO(VIR_DOMAIN_AFFECT_LIVE,
+ VIR_DOMAIN_AFFECT_CONFIG,
+ error);
+
+ conn = dom->conn;
+
+ if (conn->driver->domainDelThrottleGroup) {
+ int ret;
+ ret = conn->driver->domainDelThrottleGroup(dom, group, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(dom->conn);
+ return -1;
+}
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 84e30b711c..291844d933 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -668,6 +668,15 @@ virDomainTaintMessageTypeFromString;
virDomainTaintMessageTypeToString;
virDomainTaintTypeFromString;
virDomainTaintTypeToString;
+virDomainThrottleFilterDefFree;
+virDomainThrottleFilterFind;
+virDomainThrottleGroupAdd;
+virDomainThrottleGroupByName;
+virDomainThrottleGroupDefCopy;
+virDomainThrottleGroupDefFree;
+virDomainThrottleGroupDel;
+virDomainThrottleGroupFind;
+virDomainThrottleGroupUpdate;
virDomainTimerModeTypeFromString;
virDomainTimerModeTypeToString;
virDomainTimerNameTypeFromString;
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index 7a3492d9d7..25560bb501 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -948,4 +948,11 @@ LIBVIRT_10.2.0 {
virDomainGraphicsReload;
} LIBVIRT_10.1.0;
+LIBVIRT_10.3.0 {
+ global:
+ virDomainSetThrottleGroup;
+ virDomainGetThrottleGroup;
+ virDomainDelThrottleGroup;
+} LIBVIRT_10.2.0;
+
# .... define new API here using predicted next version number ....
diff --git a/src/remote/remote_daemon_dispatch.c b/src/remote/remote_daemon_dispatch.c
index cfc1067e40..230c898b62 100644
--- a/src/remote/remote_daemon_dispatch.c
+++ b/src/remote/remote_daemon_dispatch.c
@@ -3614,6 +3614,67 @@ remoteDispatchDomainGetBlockIoTune(virNetServer *server G_GNUC_UNUSED,
return rv;
}
+
+static int
+remoteDispatchDomainGetThrottleGroup(virNetServer *server G_GNUC_UNUSED,
+ virNetServerClient *client,
+ virNetMessage *hdr G_GNUC_UNUSED,
+ struct virNetMessageError *rerr,
+ remote_domain_get_throttle_group_args *args,
+ remote_domain_get_throttle_group_ret *ret)
+{
+ virDomainPtr dom = NULL;
+ int rv = -1;
+ virTypedParameterPtr params = NULL;
+ int nparams = 0;
+ virConnectPtr conn = remoteGetHypervisorConn(client);
+
+ if (!conn)
+ goto cleanup;
+
+ if (args->nparams > REMOTE_DOMAIN_THROTTLE_GROUP_PARAMETERS_MAX) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too large"));
+ goto cleanup;
+ }
+
+ if (args->nparams)
+ params = g_new0(virTypedParameter, args->nparams);
+ nparams = args->nparams;
+
+ if (!(dom = get_nonnull_domain(conn, args->dom)))
+ goto cleanup;
+
+ if (virDomainGetThrottleGroup(dom, args->group ? *args->group : NULL,
+ params, &nparams, args->flags) < 0)
+ goto cleanup;
+
+ /* In this case, we need to send back the number of parameters
+ * supported
+ */
+ if (args->nparams == 0) {
+ ret->nparams = nparams;
+ goto success;
+ }
+
+ /* Serialize the block I/O tuning parameters. */
+ if (virTypedParamsSerialize(params, nparams,
+ REMOTE_DOMAIN_THROTTLE_GROUP_PARAMETERS_MAX,
+ (struct _virTypedParameterRemote **) &ret->params.params_val,
+ &ret->params.params_len,
+ args->flags) < 0)
+ goto cleanup;
+
+ success:
+ rv = 0;
+
+ cleanup:
+ if (rv < 0)
+ virNetMessageSaveError(rerr);
+ virTypedParamsFree(params, nparams);
+ virObjectUnref(dom);
+ return rv;
+}
+
/*-------------------------------------------------------------*/
static int
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 7b73d97b7a..930cf666b5 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -2583,6 +2583,52 @@ static int remoteDomainGetBlockIoTune(virDomainPtr domain,
return 0;
}
+
+static int
+remoteDomainGetThrottleGroup(virDomainPtr domain,
+ const char *group,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags)
+{
+ remote_domain_get_throttle_group_args args = {0};
+ g_auto(remote_domain_get_throttle_group_ret) ret = {0};
+ struct private_data *priv = domain->conn->privateData;
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, domain);
+ args.group = group ? (char **)&group : NULL;
+ args.nparams = *nparams;
+ args.flags = flags;
+
+ if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_THROTTLE_GROUP,
+ (xdrproc_t) xdr_remote_domain_get_throttle_group_args,
+ (char *) &args,
+ (xdrproc_t) xdr_remote_domain_get_throttle_group_ret,
+ (char *) &ret) == -1) {
+ return -1;
+ }
+
+ /* Handle the case when the caller does not know the number of parameters
+ * and is asking for the number of parameters supported
+ */
+ if (*nparams == 0) {
+ *nparams = ret.nparams;
+ return 0;
+ }
+
+ if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
+ ret.params.params_len,
+ REMOTE_DOMAIN_THROTTLE_GROUP_PARAMETERS_MAX,
+ ¶ms,
+ nparams) < 0)
+ return -1;
+
+ return 0;
+
+}
+
+
static int remoteDomainGetCPUStats(virDomainPtr domain,
virTypedParameterPtr params,
unsigned int nparams,
@@ -7842,6 +7888,9 @@ static virHypervisorDriver hypervisor_driver = {
.domainSetLaunchSecurityState = remoteDomainSetLaunchSecurityState, /* 8.0.0 */
.domainFDAssociate = remoteDomainFDAssociate, /* 9.0.0 */
.domainGraphicsReload = remoteDomainGraphicsReload, /* 10.2.0 */
+ .domainSetThrottleGroup = remoteDomainSetThrottleGroup, /* 10.3.0 */
+ .domainGetThrottleGroup = remoteDomainGetThrottleGroup, /* 10.3.0 */
+ .domainDelThrottleGroup = remoteDomainDelThrottleGroup, /* 10.3.0 */
};
static virNetworkDriver network_driver = {
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 41c045ff78..4cb2c8b555 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -113,6 +113,9 @@ const REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX = 16;
/* Upper limit on list of blockio tuning parameters. */
const REMOTE_DOMAIN_BLOCK_IO_TUNE_PARAMETERS_MAX = 32;
+/* Upper limit on list of throttle group parameters. */
+const REMOTE_DOMAIN_THROTTLE_GROUP_PARAMETERS_MAX = 32;
+
/* Upper limit on list of numa parameters. */
const REMOTE_DOMAIN_NUMA_PARAMETERS_MAX = 16;
@@ -1475,6 +1478,31 @@ struct remote_domain_get_block_io_tune_ret {
int nparams;
};
+struct remote_domain_set_throttle_group_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string group;
+ remote_typed_param params<REMOTE_DOMAIN_THROTTLE_GROUP_PARAMETERS_MAX>;
+ unsigned int flags;
+};
+
+struct remote_domain_get_throttle_group_args {
+ remote_nonnull_domain dom;
+ remote_string group;
+ int nparams;
+ unsigned int flags;
+};
+
+struct remote_domain_get_throttle_group_ret {
+ remote_typed_param params<REMOTE_DOMAIN_THROTTLE_GROUP_PARAMETERS_MAX>;
+ int nparams;
+};
+
+struct remote_domain_del_throttle_group_args {
+ remote_nonnull_domain dom;
+ remote_string group;
+ unsigned int flags;
+};
+
struct remote_domain_get_cpu_stats_args {
remote_nonnull_domain dom;
unsigned int nparams;
@@ -7048,5 +7076,25 @@ enum remote_procedure {
* @generate: both
* @acl: domain:write
*/
- REMOTE_PROC_DOMAIN_GRAPHICS_RELOAD = 448
+ REMOTE_PROC_DOMAIN_GRAPHICS_RELOAD = 448,
+
+ /**
+ * @generate: both
+ * @acl: domain:write
+ * @acl: domain:save:!VIR_DOMAIN_AFFECT_CONFIG|VIR_DOMAIN_AFFECT_LIVE
+ * @acl: domain:save:VIR_DOMAIN_AFFECT_CONFIG
+ */
+ REMOTE_PROC_DOMAIN_SET_THROTTLE_GROUP = 449,
+
+ /**
+ * @generate: none
+ * @acl: domain:read
+ */
+ REMOTE_PROC_DOMAIN_GET_THROTTLE_GROUP = 450,
+
+ /**
+ * @generate: both
+ * @acl: domain:read
+ */
+ REMOTE_PROC_DOMAIN_DEL_THROTTLE_GROUP = 451
};
diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
index 4d3dc2d249..5adbea0336 100644
--- a/src/remote_protocol-structs
+++ b/src/remote_protocol-structs
@@ -1050,6 +1050,33 @@ struct remote_domain_get_block_io_tune_ret {
} params;
int nparams;
};
+struct remote_domain_set_throttle_group_args {
+ remote_nonnull_domain dom;
+ remote_nonnull_string group;
+ struct {
+ u_int params_len;
+ remote_typed_param * params_val;
+ } params;
+ u_int flags;
+};
+struct remote_domain_get_throttle_group_args {
+ remote_nonnull_domain dom;
+ remote_string group;
+ int nparams;
+ u_int flags;
+};
+struct remote_domain_get_throttle_group_ret {
+ struct {
+ u_int params_len;
+ remote_typed_param * params_val;
+ } params;
+ int nparams;
+};
+struct remote_domain_del_throttle_group_args {
+ remote_nonnull_domain dom;
+ remote_string group;
+ u_int flags;
+};
struct remote_domain_get_cpu_stats_args {
remote_nonnull_domain dom;
u_int nparams;
@@ -3755,4 +3782,7 @@ enum remote_procedure {
REMOTE_PROC_NETWORK_EVENT_CALLBACK_METADATA_CHANGE = 446,
REMOTE_PROC_NODE_DEVICE_UPDATE = 447,
REMOTE_PROC_DOMAIN_GRAPHICS_RELOAD = 448,
+ REMOTE_PROC_DOMAIN_SET_THROTTLE_GROUP = 449,
+ REMOTE_PROC_DOMAIN_GET_THROTTLE_GROUP = 450,
+ REMOTE_PROC_DOMAIN_DEL_THROTTLE_GROUP = 451,
};
--
2.34.1
_______________________________________________
Devel mailing list -- devel@lists.libvirt.org
To unsubscribe send an email to devel-leave@lists.libvirt.org
On Thu, Apr 11, 2024 at 19:01:51 -0700, wucf@linux.ibm.com wrote:
> From: Chun Feng Wu <wucf@linux.ibm.com>
>
> Support throttlegroup lifecycle management by the following implementation:
> * New methods defined in "include/libvirt/libvirt-domain.h"
> * And they're exported in "src/libvirt_public.syms"
> * Corresponding internal API is defined in "src/driver-hypervisor.h"
> * Public API calls are implemented in "src/libvirt-domain.c"
> * Wire protocol is defined in "src/remote/remote_protocol.x"
> * RPC client implementation is in "src/remote/remote_driver.c"
> * Server side dispatch is implemented in "src/remote/remote_daemon_dispatch.c"
> * Also "src/remote_protocol-structs" is updated
> * Yu Jie Gu <guyujie@linux.ibm.com> helped add
> remote_domain_set_throttle_group_args in src/remote_protocol-structs
> to fix issue reported by check-remote_protocol
Please, rather than describing where you've put the code, use this space
to describe the API itself. Which parameters it takes how it's supposed
to be used.
>
> Signed-off-by: Chun Feng Wu <wucf@linux.ibm.com>
> ---
This patch with new APIs really needs to go in after all of the other
code which allows to configure it via XML. I'll for now add some top
level comments and then get back once I see how the XML is designed
first.
> include/libvirt/libvirt-domain.h | 29 +++++
> src/driver-hypervisor.h | 22 ++++
> src/libvirt-domain.c | 190 ++++++++++++++++++++++++++++
> src/libvirt_private.syms | 9 ++
> src/libvirt_public.syms | 7 +
> src/remote/remote_daemon_dispatch.c | 61 +++++++++
> src/remote/remote_driver.c | 49 +++++++
> src/remote/remote_protocol.x | 50 +++++++-
> src/remote_protocol-structs | 30 +++++
> 9 files changed, 446 insertions(+), 1 deletion(-)
>
> diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
> index 2f5b01bbfe..5435ab7fcb 100644
> --- a/include/libvirt/libvirt-domain.h
> +++ b/include/libvirt/libvirt-domain.h
> @@ -5593,6 +5593,16 @@ typedef void (*virConnectDomainEventJobCompletedCallback)(virConnectPtr conn,
> */
> # define VIR_DOMAIN_TUNABLE_BLKDEV_WRITE_IOPS_SEC_MAX_LENGTH "blkdeviotune.write_iops_sec_max_length"
>
> +/**
> + * VIR_DOMAIN_THROTTLE_GROUP:
> + *
> + * Macro represents the name of throttle group for which the values are updated,
> + * as VIR_TYPED_PARAM_STRING.
> + *
> + * Since: 10.3.0
> + */
> +# define VIR_DOMAIN_THROTTLE_GROUP "throttlegroup.name"
So all of the APIs below take the group name as argument, why do we need
it a s typed parameter?
> +
[...]
> @@ -1726,4 +1745,7 @@ struct _virHypervisorDriver {
> virDrvDomainStartDirtyRateCalc domainStartDirtyRateCalc;
> virDrvDomainFDAssociate domainFDAssociate;
> virDrvDomainGraphicsReload domainGraphicsReload;
> + virDrvDomainSetThrottleGroup domainSetThrottleGroup;
> + virDrvDomainGetThrottleGroup domainGetThrottleGroup;
> + virDrvDomainDelThrottleGroup domainDelThrottleGroup;
> };
> diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c
> index 7c6b93963c..da88457601 100644
> --- a/src/libvirt-domain.c
> +++ b/src/libvirt-domain.c
> @@ -14162,3 +14162,193 @@ virDomainGraphicsReload(virDomainPtr domain,
> virDispatchError(domain->conn);
> return -1;
> }
> +
> +
> +/**
> + * virDomainSetThrottleGroup:
> + * @dom: pointer to domain object
> + * @group: throttle group name
> + * @params: Pointer to blkio parameter objects
> + * @nparams: Number of blkio parameters (this value can be the same or
> + * less than the number of parameters supported)
> + * @flags: bitwise-OR of virDomainModificationImpact
> + *
> + * add or change throttle group.
Please bee more specific by includingwhich names of parameters are
accepted and/or reference other APIs which do this.
> + *
> + *
> + * Returns -1 in case of error, 0 in case of success.
> + *
> + * Since: 10.3.0
Don't forget to update all of these.
> + */
> +int
> +virDomainSetThrottleGroup(virDomainPtr dom,
> + const char *group,
> + virTypedParameterPtr params,
> + int nparams,
> + unsigned int flags)
> +{
> + virConnectPtr conn;
> +
> + VIR_DOMAIN_DEBUG(dom, "params=%p, nparams=%d, flags=0x%x",
> + params, nparams, flags);
> + VIR_TYPED_PARAMS_DEBUG(params, nparams);
> +
> + virResetLastError();
> +
> + virCheckDomainReturn(dom, -1);
> + conn = dom->conn;
> +
> + virCheckReadOnlyGoto(conn->flags, error);
> + virCheckPositiveArgGoto(nparams, error);
> + virCheckNonNullArgGoto(params, error);
> +
> + if (virTypedParameterValidateSet(dom->conn, params, nparams) < 0)
> + goto error;
> +
> + if (conn->driver->domainSetThrottleGroup) {
> + int ret;
> + ret = conn->driver->domainSetThrottleGroup(dom, group, params, nparams, flags);
> + if (ret < 0)
> + goto error;
> + return ret;
> + }
> +
> + virReportUnsupportedError();
> +
> + error:
> + virDispatchError(dom->conn);
> + return -1;
> +}
> +
> +
> +/**
> + * virDomainGetThrottleGroup:
> + * @dom: pointer to domain object
> + * @group: throttle group name
> + * @params: Pointer to blkio parameter object
> + * (return value, allocated by the caller)
> + * @nparams: Pointer to number of blkio parameters
> + * @flags: bitwise-OR of virDomainModificationImpact and virTypedParameterFlags
> + *
> + * Get all parameters for specific throttle group. On input,
> + * @nparams gives the size of the @params array; on output, @nparams
> + * gives how many slots were filled with parameter information, which
> + * might be less but will not exceed the input value.
> + *
> + * As a special case, calling with @params as NULL and @nparams as 0
> + * on input will cause @nparams on output to contain the number of
> + * parameters supported by the hypervisor, either for the given @group
> + * or if @group is NULL, for all possible groups. The
> + * caller should then allocate @params array,
> + * i.e. (sizeof(@virTypedParameter) * @nparams) bytes and call the API
> + * again. See virDomainGetMemoryParameters() for more details.
We no longer do this old-style of APIs which you need to query first for
the number of parameters and then give it a reasonably-sized pointer.
Using it is really hard as it requires multiple calls and can lead to
TOCTOU races.
The new approach is that the API returns allocated array of fields and
number of fileds that are in it.
Historically the idea of handing in a pointer to be filled was that the
hypervisor code was directly running inside the library. This is no
longer the case in most cases as the library just communicates with the
daemon so there will be memory allocations and copies of the data.
> + *
> + *
> + * Returns -1 in case of error, 0 in case of success.
> + *
> + * Since: 10.3.0
> + */
> +int
> +virDomainGetThrottleGroup(virDomainPtr dom,
> + const char *group,
> + virTypedParameterPtr params,
> + int *nparams,
> + unsigned int flags)
> +{
> + virConnectPtr conn;
> + int rc;
> +
> + VIR_DOMAIN_DEBUG(dom, "params=%p, nparams=%d, flags=0x%x",
> + params, (nparams) ? *nparams : -1, flags);
[...]
_______________________________________________
Devel mailing list -- devel@lists.libvirt.org
To unsubscribe send an email to devel-leave@lists.libvirt.org
© 2016 - 2026 Red Hat, Inc.