2015-04-15 14:23:55 +00:00
|
|
|
/*
|
2015-08-10 10:39:33 +00:00
|
|
|
* admin.c: handlers for admin RPC method calls
|
2015-04-15 14:23:55 +00:00
|
|
|
*
|
2015-08-10 10:39:33 +00:00
|
|
|
* Copyright (C) 2014-2016 Red Hat, Inc.
|
2015-04-15 14:23:55 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library. If not, see
|
|
|
|
* <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
* Author: Martin Kletzander <mkletzan@redhat.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
|
|
|
#include "internal.h"
|
|
|
|
#include "libvirtd.h"
|
|
|
|
#include "libvirt_internal.h"
|
|
|
|
|
|
|
|
#include "admin_protocol.h"
|
2015-08-10 10:39:33 +00:00
|
|
|
#include "admin.h"
|
2015-08-14 07:17:01 +00:00
|
|
|
#include "admin_server.h"
|
2015-04-15 14:23:55 +00:00
|
|
|
#include "datatypes.h"
|
|
|
|
#include "viralloc.h"
|
|
|
|
#include "virerror.h"
|
|
|
|
#include "virlog.h"
|
|
|
|
#include "virnetdaemon.h"
|
|
|
|
#include "virnetserver.h"
|
|
|
|
#include "virstring.h"
|
|
|
|
#include "virthreadjob.h"
|
2015-11-23 11:41:32 +00:00
|
|
|
#include "virtypedparam.h"
|
2015-04-15 14:23:55 +00:00
|
|
|
|
|
|
|
#define VIR_FROM_THIS VIR_FROM_ADMIN
|
|
|
|
|
|
|
|
VIR_LOG_INIT("daemon.admin");
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
remoteAdmClientFreeFunc(void *data)
|
|
|
|
{
|
|
|
|
struct daemonAdmClientPrivate *priv = data;
|
|
|
|
|
|
|
|
virMutexDestroy(&priv->lock);
|
|
|
|
virObjectUnref(priv->dmn);
|
|
|
|
VIR_FREE(priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *
|
|
|
|
remoteAdmClientInitHook(virNetServerClientPtr client ATTRIBUTE_UNUSED,
|
|
|
|
void *opaque)
|
|
|
|
{
|
|
|
|
struct daemonAdmClientPrivate *priv;
|
|
|
|
|
|
|
|
if (VIR_ALLOC(priv) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (virMutexInit(&priv->lock) < 0) {
|
|
|
|
VIR_FREE(priv);
|
|
|
|
virReportSystemError(errno, "%s", _("unable to init mutex"));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't necessarily need to ref this object right now as there
|
|
|
|
* must be one ref being held throughout the life of the daemon,
|
|
|
|
* but let's just be safe for future.
|
|
|
|
*/
|
|
|
|
priv->dmn = virObjectRef(opaque);
|
|
|
|
|
|
|
|
return priv;
|
|
|
|
}
|
|
|
|
|
2015-08-14 07:17:01 +00:00
|
|
|
/* Helpers */
|
|
|
|
|
2016-04-14 22:20:11 +00:00
|
|
|
static virNetServerPtr
|
|
|
|
get_nonnull_server(virNetDaemonPtr dmn, admin_nonnull_server srv)
|
|
|
|
{
|
|
|
|
return virNetDaemonGetServer(dmn, srv.name);
|
|
|
|
}
|
|
|
|
|
2015-08-14 07:17:01 +00:00
|
|
|
static void
|
|
|
|
make_nonnull_server(admin_nonnull_server *srv_dst,
|
2016-03-01 14:31:18 +00:00
|
|
|
virNetServerPtr srv_src)
|
2015-08-14 07:17:01 +00:00
|
|
|
{
|
2016-03-01 14:31:18 +00:00
|
|
|
ignore_value(VIR_STRDUP_QUIET(srv_dst->name, virNetServerGetName(srv_src)));
|
2015-08-14 07:17:01 +00:00
|
|
|
}
|
|
|
|
|
2016-04-28 08:26:25 +00:00
|
|
|
static virNetServerClientPtr
|
|
|
|
get_nonnull_client(virNetServerPtr srv, admin_nonnull_client clnt)
|
|
|
|
{
|
|
|
|
return virNetServerGetClient(srv, clnt.id);
|
|
|
|
}
|
|
|
|
|
2016-04-14 22:20:11 +00:00
|
|
|
static void
|
|
|
|
make_nonnull_client(admin_nonnull_client *clt_dst,
|
|
|
|
virNetServerClientPtr clt_src)
|
|
|
|
{
|
|
|
|
clt_dst->id = virNetServerClientGetID(clt_src);
|
|
|
|
clt_dst->timestamp = virNetServerClientGetTimestamp(clt_src);
|
|
|
|
clt_dst->transport = virNetServerClientGetTransport(clt_src);
|
|
|
|
}
|
|
|
|
|
2015-04-15 14:23:55 +00:00
|
|
|
/* Functions */
|
|
|
|
static int
|
2015-12-10 12:46:45 +00:00
|
|
|
adminDispatchConnectOpen(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
|
|
virNetServerClientPtr client,
|
|
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
|
|
virNetMessageErrorPtr rerr,
|
|
|
|
struct admin_connect_open_args *args)
|
2015-04-15 14:23:55 +00:00
|
|
|
{
|
|
|
|
unsigned int flags;
|
|
|
|
struct daemonAdmClientPrivate *priv =
|
|
|
|
virNetServerClientGetPrivateData(client);
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
VIR_DEBUG("priv=%p dmn=%p", priv, priv->dmn);
|
|
|
|
virMutexLock(&priv->lock);
|
|
|
|
|
|
|
|
flags = args->flags;
|
|
|
|
virCheckFlagsGoto(0, cleanup);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
cleanup:
|
|
|
|
if (ret < 0)
|
|
|
|
virNetMessageSaveError(rerr);
|
|
|
|
virMutexUnlock(&priv->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2015-12-10 12:46:45 +00:00
|
|
|
adminDispatchConnectClose(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
|
|
virNetServerClientPtr client,
|
|
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
|
|
virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED)
|
2015-04-15 14:23:55 +00:00
|
|
|
{
|
|
|
|
virNetServerClientDelayedClose(client);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-10-05 15:17:51 +00:00
|
|
|
static int
|
2015-12-10 12:46:45 +00:00
|
|
|
adminConnectGetLibVersion(virNetDaemonPtr dmn ATTRIBUTE_UNUSED,
|
|
|
|
unsigned long long *libVer)
|
2015-10-05 15:17:51 +00:00
|
|
|
{
|
|
|
|
if (libVer)
|
|
|
|
*libVer = LIBVIR_VERSION_NUMBER;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-23 11:41:32 +00:00
|
|
|
static int
|
|
|
|
adminDispatchServerGetThreadpoolParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
|
|
virNetServerClientPtr client,
|
|
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
|
|
virNetMessageErrorPtr rerr,
|
|
|
|
struct admin_server_get_threadpool_parameters_args *args,
|
|
|
|
struct admin_server_get_threadpool_parameters_ret *ret)
|
|
|
|
{
|
|
|
|
int rv = -1;
|
|
|
|
virNetServerPtr srv = NULL;
|
|
|
|
virTypedParameterPtr params = NULL;
|
|
|
|
int nparams = 0;
|
|
|
|
struct daemonAdmClientPrivate *priv =
|
|
|
|
virNetServerClientGetPrivateData(client);
|
|
|
|
|
|
|
|
if (!(srv = virNetDaemonGetServer(priv->dmn, args->srv.name)))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (adminServerGetThreadPoolParameters(srv, ¶ms, &nparams,
|
|
|
|
args->flags) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (nparams > ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Number of threadpool parameters %d exceeds max "
|
|
|
|
"allowed limit: %d"), nparams,
|
|
|
|
ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virTypedParamsSerialize(params, nparams,
|
|
|
|
(virTypedParameterRemotePtr *) &ret->params.params_val,
|
|
|
|
&ret->params.params_len, 0) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
rv = 0;
|
|
|
|
cleanup:
|
|
|
|
if (rv < 0)
|
|
|
|
virNetMessageSaveError(rerr);
|
|
|
|
|
|
|
|
virTypedParamsFree(params, nparams);
|
|
|
|
virObjectUnref(srv);
|
|
|
|
return rv;
|
|
|
|
}
|
admin: Introduce virAdmServerSetThreadPoolParameters
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.
Signed-off-by: Erik Skultety <eskultet@redhat.com>
2016-02-22 13:24:04 +00:00
|
|
|
|
|
|
|
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->srv.name))) {
|
|
|
|
virReportError(VIR_ERR_NO_SERVER,
|
|
|
|
_("no server with matching name '%s' found"),
|
|
|
|
args->srv.name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virTypedParamsDeserialize((virTypedParameterRemotePtr) args->params.params_val,
|
|
|
|
args->params.params_len,
|
|
|
|
ADMIN_SERVER_THREADPOOL_PARAMETERS_MAX,
|
|
|
|
¶ms,
|
|
|
|
&nparams) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
|
|
|
|
if (adminServerSetThreadPoolParameters(srv, params,
|
|
|
|
nparams, args->flags) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
rv = 0;
|
|
|
|
cleanup:
|
|
|
|
if (rv < 0)
|
|
|
|
virNetMessageSaveError(rerr);
|
|
|
|
|
|
|
|
virTypedParamsFree(params, nparams);
|
|
|
|
virObjectUnref(srv);
|
|
|
|
return rv;
|
|
|
|
}
|
2016-04-22 11:05:42 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
adminDispatchClientGetInfo(virNetServerPtr server ATTRIBUTE_UNUSED,
|
|
|
|
virNetServerClientPtr client,
|
|
|
|
virNetMessagePtr msg ATTRIBUTE_UNUSED,
|
|
|
|
virNetMessageErrorPtr rerr,
|
|
|
|
struct admin_client_get_info_args *args,
|
|
|
|
struct admin_client_get_info_ret *ret)
|
|
|
|
{
|
|
|
|
int rv = -1;
|
|
|
|
virNetServerPtr srv = NULL;
|
|
|
|
virNetServerClientPtr clnt = NULL;
|
|
|
|
virTypedParameterPtr params = NULL;
|
|
|
|
int nparams = 0;
|
|
|
|
struct daemonAdmClientPrivate *priv =
|
|
|
|
virNetServerClientGetPrivateData(client);
|
|
|
|
|
|
|
|
if (!(srv = virNetDaemonGetServer(priv->dmn, args->clnt.srv.name))) {
|
|
|
|
virReportError(VIR_ERR_NO_SERVER,
|
|
|
|
_("no server with matching name '%s' found"),
|
|
|
|
args->clnt.srv.name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(clnt = virNetServerGetClient(srv, args->clnt.id))) {
|
|
|
|
virReportError(VIR_ERR_NO_CLIENT,
|
2016-05-04 19:15:11 +00:00
|
|
|
_("no client with matching id '%llu' found"),
|
|
|
|
(unsigned long long) args->clnt.id);
|
2016-04-22 11:05:42 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (adminClientGetInfo(clnt, ¶ms, &nparams, args->flags) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (nparams > ADMIN_CLIENT_INFO_PARAMETERS_MAX) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Number of client info parameters %d exceeds max "
|
|
|
|
"allowed limit: %d"), nparams,
|
|
|
|
ADMIN_CLIENT_INFO_PARAMETERS_MAX);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virTypedParamsSerialize(params, nparams,
|
|
|
|
(virTypedParameterRemotePtr *) &ret->params.params_val,
|
|
|
|
&ret->params.params_len,
|
|
|
|
VIR_TYPED_PARAM_STRING_OKAY) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
rv = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (rv < 0)
|
|
|
|
virNetMessageSaveError(rerr);
|
|
|
|
|
|
|
|
virTypedParamsFree(params, nparams);
|
|
|
|
virObjectUnref(clnt);
|
|
|
|
virObjectUnref(srv);
|
|
|
|
return rv;
|
|
|
|
}
|
2015-04-15 14:23:55 +00:00
|
|
|
#include "admin_dispatch.h"
|