Make all relevant changes to admin protocol, in order to achieve $(subj) --- cfg.mk | 2 +- src/admin/admin_protocol.x | 24 ++++++++++++++++++++++++ src/admin_protocol-structs | 25 +++++++++++++++++++++++++ 3 files changed, 50 insertions(+), 1 deletion(-) diff --git a/cfg.mk b/cfg.mk index 5b864af..d1e58be 100644 --- a/cfg.mk +++ b/cfg.mk @@ -1225,7 +1225,7 @@ exclude_file_name_regexp--sc_prohibit_include_public_headers_brackets = \ ^(tools/|examples/|include/libvirt/(virterror|libvirt(-(admin|qemu|lxc))?)\.h$$) exclude_file_name_regexp--sc_prohibit_int_ijk = \ - ^(src/remote_protocol-structs|src/remote/remote_protocol.x|cfg.mk|include/)$ + ^(src/remote_protocol-structs|src/remote/remote_protocol.x|cfg.mk|include/|src/admin_protocol-structs|src/admin/admin_protocol.x)$ exclude_file_name_regexp--sc_prohibit_getenv = \ ^tests/.*\.[ch]$$ diff --git a/src/admin/admin_protocol.x b/src/admin/admin_protocol.x index 089ce57..7b0a3b3 100644 --- a/src/admin/admin_protocol.x +++ b/src/admin/admin_protocol.x @@ -22,6 +22,7 @@ * Author: Martin Kletzander <mkletzan(a)redhat.com&gt; */ +%#include <libvirt/libvirt-admin.h> %#include "virxdrdefs.h" /*----- Data types. -----*/ @@ -41,12 +42,35 @@ typedef string admin_nonnull_string<ADMIN_STRING_MAX>; /* A long string, which may be NULL. */ typedef admin_nonnull_string *admin_string; +union admin_typed_param_value switch (int type) { + case VIR_TYPED_PARAM_INT: + int i; + case VIR_TYPED_PARAM_UINT: + unsigned int ui; + case VIR_TYPED_PARAM_LLONG: + hyper l; + case VIR_TYPED_PARAM_ULLONG: + unsigned hyper ul; + case VIR_TYPED_PARAM_DOUBLE: + double d; + case VIR_TYPED_PARAM_BOOLEAN: + int b; + case VIR_TYPED_PARAM_STRING: + admin_nonnull_string s; +}; + +struct admin_typed_param { + admin_nonnull_string field; + admin_typed_param_value value; +}; + /* A server which may NOT be NULL */ struct admin_nonnull_server { admin_nonnull_string name; }; /*----- Protocol. -----*/ + struct admin_connect_open_args { unsigned int flags; }; diff --git a/src/admin_protocol-structs b/src/admin_protocol-structs index 8f2633a..7153a89 100644 --- a/src/admin_protocol-structs +++ b/src/admin_protocol-structs @@ -1,4 +1,29 @@ /* -*- c -*- */ +enum { + VIR_TYPED_PARAM_INT = 1, + VIR_TYPED_PARAM_UINT = 2, + VIR_TYPED_PARAM_LLONG = 3, + VIR_TYPED_PARAM_ULLONG = 4, + VIR_TYPED_PARAM_DOUBLE = 5, + VIR_TYPED_PARAM_BOOLEAN = 6, + VIR_TYPED_PARAM_STRING = 7, +}; +struct admin_typed_param_value { + int type; + union { + int i; + u_int ui; + int64_t l; + uint64_t ul; + double d; + int b; + admin_nonnull_string s; + } admin_typed_param_value_u; +}; +struct admin_typed_param { + admin_nonnull_string field; + admin_typed_param_value value; +}; struct admin_nonnull_server { admin_nonnull_string name; }; -- 2.4.3

Otherwise 'Unknown' error will be returned to client. --- po/POTFILES.in | 1 + src/util/virthreadpool.c | 1 + 2 files changed, 2 insertions(+) diff --git a/po/POTFILES.in b/po/POTFILES.in index 27980df..455b799 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -237,6 +237,7 @@ src/util/virstoragefile.c src/util/virstring.c src/util/virsysinfo.c src/util/virthreadjob.c +src/util/virthreadpool.c src/util/virtime.c src/util/virtpm.c src/util/virtypedparam.c diff --git a/src/util/virthreadpool.c b/src/util/virthreadpool.c index 8af4ec0..e2e9fe4 100644 --- a/src/util/virthreadpool.c +++ b/src/util/virthreadpool.c @@ -183,6 +183,7 @@ virThreadPoolExpand(virThreadPoolPtr pool, size_t gain, bool priority) true, data) < 0) { VIR_FREE(data); + virReportSystemError(errno, "%s", _("Failed to create thread")); goto error; } } -- 2.4.3

Before any getter or setter methods can be introduced, first specify a set of public attributes/flags that these methods will be compatible with. --- include/libvirt/libvirt-admin.h | 61 +++++++++++++++++++++++++++++++++++++++++ src/admin/admin_protocol.x | 3 ++ 2 files changed, 64 insertions(+) diff --git a/include/libvirt/libvirt-admin.h b/include/libvirt/libvirt-admin.h index 1f62a4d..e12c5ce 100644 --- a/include/libvirt/libvirt-admin.h +++ b/include/libvirt/libvirt-admin.h @@ -108,6 +108,67 @@ const char *virAdmServerGetName(virAdmServerPtr srv); virAdmServerPtr virAdmConnectServerLookupByName(virAdmConnectPtr conn, const char *name); + +/* Manage threadpool attributes */ + +/** + * VIR_THREADPOOL_WORKERS_MIN: + * Macro for the threadpool minWorkers limit: represents the bottom limit to + * number of active workers in threadpool, as uint. + */ + +# define VIR_THREADPOOL_WORKERS_MIN "minWorkers" + +/** + * VIR_THREADPOOL_WORKERS_MAX: + * Macro for the threadpool maxWorkers limit: represents the upper limit to + * number of active workers in threadpool, as uint. The value of this limit has + * to be greater than VIR_THREADPOOL_WORKERS_MIN at all times. + */ + +# define VIR_THREADPOOL_WORKERS_MAX "maxWorkers" + +/** + * VIR_THREADPOOL_WORKERS_PRIORITY: + * Macro for the threadpool nPrioWorkers attribute: represents the current number + * of active priority workers in threadpool, as uint. + */ + +# define VIR_THREADPOOL_WORKERS_PRIORITY "prioWorkers" + +/** + * VIR_THREADPOOL_WORKERS_FREE: + * Macro for the threadpool freeWorkers attribute: represents the current number + * of free workers available to accomplish a job, as uint. + * + * NOTE: This attribute is read-only and any attempt to set it will be denied + * by daemon + */ + +# define VIR_THREADPOOL_WORKERS_FREE "freeWorkers" + +/** + * VIR_THREADPOOL_WORKERS_CURRENT: + * Macro for the threadpool nWorkers attribute: represents the current number + * of active ordinary workers in threadpool, as uint. + * + * NOTE: This attribute is read-only and any attempt to set it will be denied + * by daemon + */ + +# define VIR_THREADPOOL_WORKERS_CURRENT "nWorkers" + +/** + * VIR_THREADPOOL_JOB_QUEUE_DEPTH: + * Macro for the threadpool jobQueueDepth attribute: represents the current + * number of jobs waiting in a queue to be processed, as uint. + * + * NOTE: This attribute is read-only and any attempt to set it will be denied + * by daemon + */ + +# define VIR_THREADPOOL_JOB_QUEUE_DEPTH "jobQueueDepth" + # ifdef __cplusplus } # endif diff --git a/src/admin/admin_protocol.x b/src/admin/admin_protocol.x index 09b9c7d..9d56a69 100644 --- a/src/admin/admin_protocol.x +++ b/src/admin/admin_protocol.x @@ -36,6 +36,9 @@ const ADMIN_STRING_MAX = 4194304; /* Upper limit on list of servers */ const ADMIN_SERVER_LIST_MAX = 16384; +/* Upper limit on number of threadpool stats */ +const ADMIN_SERVER_THREADPOOL_STATS_MAX = 32; + /* A long string, which may NOT be NULL. */ typedef string admin_nonnull_string<ADMIN_STRING_MAX>; -- 2.4.3

Since threadpool increments the current number of threads according to current load, i.e. how many jobs are waiting in the queue. The count however, is constrained by max and min limits of workers. The logic of this new API works like this: 1) setting the minimum a) When the limit is increased, depending on the current number of threads, new threads are possibly spawned if the current number of threads is less than the new minimum limit b) Decreasing the minimum limit has no possible effect on the current number of threads 2) setting the maximum a) Icreasing the maximum limit has no immediate effect on the current number of threads, it only allows the threadpool to spawn more threads when new jobs, that would otherwise end up queued, arrive. b) Decreasing the maximum limit may affect the current number of threads, if the current number of threads is less than the new maximum limit. Since there may be some ongoing time-consuming jobs that would effectively block this API from killing any threads. Therefore, this API is asynchronous with best-effort execution, i.e. the necessary number of workers will be terminated once they finish their previous job, unless other workers had already terminated, decreasing the limit to the requested value. 3) setting priority workers - both increase and decrease in count of these workers have an immediate impact on the current number of workers, new ones will be spawned or some of them get terminated respectively. --- daemon/admin.c | 43 +++++++++++++++++++++++ daemon/admin_server.c | 43 +++++++++++++++++++++++ daemon/admin_server.h | 5 +++ include/libvirt/libvirt-admin.h | 5 +++ src/admin/admin_protocol.x | 13 ++++++- src/admin/admin_remote.c | 34 ++++++++++++++++++ src/admin_protocol-structs | 9 +++++ src/libvirt-admin.c | 37 ++++++++++++++++++++ src/libvirt_admin_private.syms | 1 + src/libvirt_admin_public.syms | 1 + src/libvirt_private.syms | 1 + src/rpc/virnetserver.c | 15 ++++++++ src/util/virthreadpool.c | 77 +++++++++++++++++++++++++++++++++++++++-- src/util/virthreadpool.h | 5 +++ 14 files changed, 285 insertions(+), 4 deletions(-) diff --git a/daemon/admin.c b/daemon/admin.c index 8dc396e..af60ea5 100644 --- a/daemon/admin.c +++ b/daemon/admin.c @@ -264,4 +264,47 @@ adminDispatchServerGetThreadpoolParameters(virNetServerPtr server ATTRIBUTE_UNUS virObjectUnref(srv); return rv; } + +static int +adminDispatchServerSetThreadpoolParameters(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + struct admin_server_set_threadpool_parameters_args *args) +{ + int rv = -1; + virNetServerPtr srv = NULL; + virTypedParameterPtr params = NULL; + int nparams = 0; + struct daemonAdmClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!(srv = virNetDaemonGetServer(priv->dmn, args->server.name))) { + virReportError(VIR_ERR_NO_SERVER, + _("no server with matching name '%s' found"), + args->server.name); + goto cleanup; + } + + if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val, + args->params.params_len, + ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX, + &params, + &nparams) < 0) + goto cleanup; + + + if (adminDaemonSetThreadPoolParameters(srv, params, + nparams, args->flags) < 0) + goto cleanup; + + rv = 0; + cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + + virTypedParamsFree(params, nparams); + virObjectUnref(srv); + return rv; +} #include "admin_dispatch.h" diff --git a/daemon/admin_server.c b/daemon/admin_server.c index 861a98c..11ec139 100644 --- a/daemon/admin_server.c +++ b/daemon/admin_server.c @@ -32,6 +32,7 @@ #include "virnetserver.h" #include "virstring.h" #include "virthreadpool.h" +#include "virtypedparam.h" #define VIR_FROM_THIS VIR_FROM_ADMIN @@ -158,3 +159,45 @@ adminDaemonGetThreadPoolParameters(virNetServerPtr srv, return ret; } + +int +adminDaemonSetThreadPoolParameters(virNetServerPtr srv, + virTypedParameterPtr params, + int nparams, + unsigned int flags) +{ + long long int minWorkers = -1; + long long int maxWorkers = -1; + long long int prioWorkers = -1; + virTypedParameterPtr param = NULL; + + virCheckFlags(0, -1); + + if (virTypedParamsValidate(params, nparams, + VIR_THREADPOOL_WORKERS_MIN, + VIR_TYPED_PARAM_UINT, + VIR_THREADPOOL_WORKERS_MAX, + VIR_TYPED_PARAM_UINT, + VIR_THREADPOOL_WORKERS_PRIORITY, + VIR_TYPED_PARAM_UINT, + NULL) < 0) + return -1; + + if ((param = virTypedParamsGet(params, nparams, + VIR_THREADPOOL_WORKERS_MIN))) + minWorkers = param->value.ui; + + if ((param = virTypedParamsGet(params, nparams, + VIR_THREADPOOL_WORKERS_MAX))) + maxWorkers = param->value.ui; + + if ((param = virTypedParamsGet(params, nparams, + VIR_THREADPOOL_WORKERS_PRIORITY))) + prioWorkers = param->value.ui; + + if (virNetServerSetThreadPoolParameters(srv, minWorkers, + maxWorkers, prioWorkers) < 0) + return -1; + + return 0; +} diff --git a/daemon/admin_server.h b/daemon/admin_server.h index 7794bf1..86958f3 100644 --- a/daemon/admin_server.h +++ b/daemon/admin_server.h @@ -40,5 +40,10 @@ adminDaemonGetThreadPoolParameters(virNetServerPtr srv, virTypedParameterPtr *params, int *nparams, unsigned int flags); +int +adminDaemonSetThreadPoolParameters(virNetServerPtr srv, + virTypedParameterPtr params, + int nparams, + unsigned int flags); #endif /* __LIBVIRTD_ADMIN_SERVER_H__ */ diff --git a/include/libvirt/libvirt-admin.h b/include/libvirt/libvirt-admin.h index b96545b..d24ba7c 100644 --- a/include/libvirt/libvirt-admin.h +++ b/include/libvirt/libvirt-admin.h @@ -175,6 +175,11 @@ int virAdmServerGetThreadPoolParameters(virAdmServerPtr srv, int *nparams, unsigned int flags); +int virAdmServerSetThreadPoolParameters(virAdmServerPtr srv, + virTypedParameterPtr params, + int nparams, + unsigned int flags); + # ifdef __cplusplus } # endif diff --git a/src/admin/admin_protocol.x b/src/admin/admin_protocol.x index ed7bf67..bf98a09 100644 --- a/src/admin/admin_protocol.x +++ b/src/admin/admin_protocol.x @@ -109,6 +109,12 @@ struct admin_server_get_threadpool_parameters_ret { admin_typed_param params<ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX>; }; +struct admin_server_set_threadpool_parameters_args { + admin_nonnull_server server; + admin_typed_param params<ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX>; + unsigned int flags; +}; + /* Define the program number, protocol version and procedure numbers here. */ const ADMIN_PROGRAM = 0x06900690; const ADMIN_PROTOCOL_VERSION = 1; @@ -160,5 +166,10 @@ enum admin_procedure { /** * @generate: none */ - ADMIN_PROC_SERVER_GET_THREADPOOL_PARAMETERS = 6 + ADMIN_PROC_SERVER_GET_THREADPOOL_PARAMETERS = 6, + + /** + * @generate: none + */ + ADMIN_PROC_SERVER_SET_THREADPOOL_PARAMETERS = 7 }; diff --git a/src/admin/admin_remote.c b/src/admin/admin_remote.c index 2717a17..0318ff2 100644 --- a/src/admin/admin_remote.c +++ b/src/admin/admin_remote.c @@ -357,3 +357,37 @@ remoteAdminServerGetThreadPoolParameters(virAdmServerPtr srv, virObjectUnlock(priv); return rv; } + +static int +remoteAdminServerSetThreadPoolParameters(virAdmServerPtr srv, + virTypedParameterPtr params, + int nparams, + unsigned int flags) +{ + remoteAdminPrivPtr priv = srv->conn->privateData; + int rv = -1; + admin_server_set_threadpool_parameters_args args; + + args.flags = flags; + make_nonnull_server(&args.server, srv); + + if (virTypedParamsSerialize(params, nparams, + (virTypedParameterRemotePtr *) &args.params.params_val, + &args.params.params_len, + 0) < 0) + goto cleanup; + + + if (call(srv->conn, 0, ADMIN_PROC_SERVER_SET_THREADPOOL_PARAMETERS, + (xdrproc_t)xdr_admin_server_set_threadpool_parameters_args, (char *) &args, + (xdrproc_t)xdr_void, (char *) NULL) == -1) + goto cleanup; + + rv = 0; + + cleanup: + virTypedParamsRemoteFree((virTypedParameterRemotePtr) args.params.params_val, + args.params.params_len); + virObjectUnlock(priv); + return rv; +} diff --git a/src/admin_protocol-structs b/src/admin_protocol-structs index d0bc367..ccc9998 100644 --- a/src/admin_protocol-structs +++ b/src/admin_protocol-structs @@ -60,6 +60,14 @@ struct admin_server_get_threadpool_parameters_ret { admin_typed_param * params_val; } params; }; +struct admin_server_set_threadpool_parameters_args { + admin_nonnull_server server; + struct { + u_int params_len; + admin_typed_param * params_val; + } params; + u_int flags; +}; enum admin_procedure { ADMIN_PROC_CONNECT_OPEN = 1, ADMIN_PROC_CONNECT_CLOSE = 2, @@ -67,4 +75,5 @@ enum admin_procedure { ADMIN_PROC_CONNECT_LIST_SERVERS = 4, ADMIN_PROC_CONNECT_SERVER_LOOKUP_BY_NAME = 5, ADMIN_PROC_SERVER_GET_THREADPOOL_PARAMETERS = 6, + ADMIN_PROC_SERVER_SET_THREADPOOL_PARAMETERS = 7, }; diff --git a/src/libvirt-admin.c b/src/libvirt-admin.c index 6165159..c5a33bc 100644 --- a/src/libvirt-admin.c +++ b/src/libvirt-admin.c @@ -710,3 +710,40 @@ virAdmServerGetThreadPoolParameters(virAdmServerPtr srv, virDispatchError(NULL); return -1; } + +/** + * virAdmServerSetThreadPoolParameters: + * @srv: a valid server object reference + * @params: pointer to threadpool parameter objects + * @nparams: number of parameters in @params + * @flags: bitwise-OR of extra flags virAdmServerSetThreadPoolParametersFlags + * + * Change server threadpool parameters according to @params. Note that some + * tunables are read-only, thus any attempt to set them will result in a + * failure. + * + * Returns 0 on success, -1 in case of an error. + */ +int +virAdmServerSetThreadPoolParameters(virAdmServerPtr srv, + virTypedParameterPtr params, + int nparams, + unsigned int flags) +{ + VIR_DEBUG("srv=%p, params=%p, nparams=%x, flags=%x", + srv, params, nparams, flags); + + virResetLastError(); + + virCheckAdmServerReturn(srv, NULL); + virCheckNonNullArgGoto(params, error); + + if (remoteAdminServerSetThreadPoolParameters(srv, params, + nparams, flags) < 0) + goto error; + + return 0; + error: + virDispatchError(NULL); + return -1; +} diff --git a/src/libvirt_admin_private.syms b/src/libvirt_admin_private.syms index 7d3067f..95dfe35 100644 --- a/src/libvirt_admin_private.syms +++ b/src/libvirt_admin_private.syms @@ -14,6 +14,7 @@ xdr_admin_connect_server_lookup_by_name_args; xdr_admin_connect_server_lookup_by_name_ret; xdr_admin_server_get_threadpool_parameters_args; xdr_admin_server_get_threadpool_parameters_ret; +xdr_admin_server_set_threadpool_parameters_args; # datatypes.h virAdmConnectClass; diff --git a/src/libvirt_admin_public.syms b/src/libvirt_admin_public.syms index e89ad75..f5a8fc0 100644 --- a/src/libvirt_admin_public.syms +++ b/src/libvirt_admin_public.syms @@ -26,4 +26,5 @@ LIBVIRT_ADMIN_1.3.0 { virAdmServerGetName; virAdmServerGetThreadPoolParameters; virAdmServerFree; + virAdmServerSetThreadPoolParameters; }; diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 7658ebf..ecd8c46 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -2326,6 +2326,7 @@ virThreadPoolGetMinWorkers; virThreadPoolGetPriorityWorkers; virThreadPoolNewFull; virThreadPoolSendJob; +virThreadPoolSetParameters; # util/virtime.h diff --git a/src/rpc/virnetserver.c b/src/rpc/virnetserver.c index cc809bf..6922443 100644 --- a/src/rpc/virnetserver.c +++ b/src/rpc/virnetserver.c @@ -883,3 +883,18 @@ virNetServerGetThreadPoolParameters(virNetServerPtr srv, virObjectUnlock(srv); return 0; } + +int +virNetServerSetThreadPoolParameters(virNetServerPtr srv, + long long int minWorkers, + long long int maxWorkers, + long long int prioWorkers) +{ + int ret; + + virObjectLock(srv); + ret = virThreadPoolSetParameters(srv->workers, minWorkers, + maxWorkers, prioWorkers); + virObjectUnlock(srv); + return ret; +} diff --git a/src/util/virthreadpool.c b/src/util/virthreadpool.c index 518b880..9dd8fba 100644 --- a/src/util/virthreadpool.c +++ b/src/util/virthreadpool.c @@ -73,6 +73,7 @@ struct _virThreadPool { size_t nWorkers; virThreadPtr workers; + size_t maxPrioWorkers; size_t nPrioWorkers; virThreadPtr prioWorkers; virCond prioCond; @@ -84,12 +85,22 @@ struct virThreadPoolWorkerData { bool priority; }; +/* Test whether the worker needs to quit if the current number of workers @count + * is greater than @limit actually allows. + */ +static inline bool virThreadPoolWorkerQuitHelper(size_t count, size_t limit) +{ + return count > limit; +} + static void virThreadPoolWorker(void *opaque) { struct virThreadPoolWorkerData *data = opaque; virThreadPoolPtr pool = data->pool; virCondPtr cond = data->cond; bool priority = data->priority; + size_t *curWorkers = priority ? &pool->nPrioWorkers : &pool->nWorkers; + size_t *maxLimit = priority ? &pool->maxPrioWorkers : &pool->maxWorkers; virThreadPoolJobPtr job = NULL; VIR_FREE(data); @@ -97,6 +108,14 @@ static void virThreadPoolWorker(void *opaque) virMutexLock(&pool->mutex); while (1) { + /* In order to support async worker termination, we need ensure that + * both busy and free workers know if they need to terminated. Thus, + * busy workers need to check for this fact before they start waiting for + * another job (and before taking another one from the queue); and + * free workers need to check for this right after waking up. + */ + if (virThreadPoolWorkerQuitHelper(*curWorkers, *maxLimit)) + goto out; while (!pool->quit && ((!priority && !pool->jobList.head) || (priority && !pool->jobList.firstPrio))) { @@ -109,6 +128,9 @@ static void virThreadPoolWorker(void *opaque) } if (!priority) pool->freeWorkers--; + + if (virThreadPoolWorkerQuitHelper(*curWorkers, *maxLimit)) + goto out; } if (pool->quit) @@ -160,12 +182,12 @@ static void virThreadPoolWorker(void *opaque) static int virThreadPoolExpand(virThreadPoolPtr pool, size_t gain, bool priority) { - virThreadPtr workers = priority ? pool->prioWorkers : pool->workers; + virThreadPtr *workers = priority ? &pool->prioWorkers : &pool->workers; size_t *curWorkers = priority ? &pool->nPrioWorkers : &pool->nWorkers; size_t i = 0; struct virThreadPoolWorkerData *data = NULL; - if (VIR_EXPAND_N(workers, *curWorkers, gain) < 0) + if (VIR_EXPAND_N(*workers, *curWorkers, gain) < 0) return -1; for (i = 0; i < gain; i++) { @@ -176,7 +198,7 @@ virThreadPoolExpand(virThreadPoolPtr pool, size_t gain, bool priority) data->cond = priority ? &pool->prioCond : &pool->cond; data->priority = priority; - if (virThreadCreateFull(&workers[i], + if (virThreadCreateFull(&(*workers)[i], false, virThreadPoolWorker, pool->jobFuncName, @@ -226,6 +248,7 @@ virThreadPoolNewFull(size_t minWorkers, pool->minWorkers = minWorkers; pool->maxWorkers = maxWorkers; + pool->maxPrioWorkers = prioWorkers; if (virThreadPoolExpand(pool, minWorkers, false) < 0) goto error; @@ -363,3 +386,51 @@ int virThreadPoolSendJob(virThreadPoolPtr pool, virMutexUnlock(&pool->mutex); return -1; } + +int +virThreadPoolSetParameters(virThreadPoolPtr pool, + long long int minWorkers, + long long int maxWorkers, + long long int prioWorkers) +{ + virMutexLock(&pool->mutex); + + if ((minWorkers >= 0 && minWorkers > pool->maxWorkers) || + (maxWorkers >= 0 && maxWorkers < pool->minWorkers) || + (minWorkers >= 0 && maxWorkers >= 0 && minWorkers > maxWorkers)) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("minWorkers cannot be larger than maxWorkers")); + goto error; + } + + if (minWorkers >= 0) { + if ((size_t) minWorkers > pool->nWorkers && + virThreadPoolExpand(pool, minWorkers - pool->nWorkers, + false) < 0) + goto error; + pool->minWorkers = minWorkers; + } + + if (maxWorkers >= 0) { + pool->maxWorkers = maxWorkers; + virCondBroadcast(&pool->cond); + } + + if (prioWorkers >= 0) { + if (prioWorkers < pool->nPrioWorkers) { + virCondBroadcast(&pool->prioCond); + } else if ((size_t) prioWorkers > pool->nPrioWorkers && + virThreadPoolExpand(pool, prioWorkers - pool->nPrioWorkers, + true) < 0) { + goto error; + } + pool->maxPrioWorkers = prioWorkers; + } + + virMutexUnlock(&pool->mutex); + return 0; + + error: + virMutexUnlock(&pool->mutex); + return -1; +} diff --git a/src/util/virthreadpool.h b/src/util/virthreadpool.h index bc0c907..e1f362f 100644 --- a/src/util/virthreadpool.h +++ b/src/util/virthreadpool.h @@ -57,4 +57,9 @@ int virThreadPoolSendJob(virThreadPoolPtr pool, void *jobdata) ATTRIBUTE_NONNULL(1) ATTRIBUTE_RETURN_CHECK; +int virThreadPoolSetParameters(virThreadPoolPtr pool, + long long int minWorkers, + long long int maxWorkers, + long long int prioWorkers); + #endif -- 2.4.3