This allows to have more servers in one daemon which helps isolating
some resources.
Signed-off-by: Martin Kletzander <mkletzan@xxxxxxxxxx>
---
daemon/libvirtd.c | 101 ++---
docs/internals.html.in | 4 +-
docs/internals/rpc.html.in | 7 +
po/POTFILES.in | 1 +
src/Makefile.am | 1 +
src/libvirt_remote.syms | 30 +-
src/locking/lock_daemon.c | 75 ++--
src/locking/lock_daemon_config.c | 2 +-
src/locking/lock_daemon_dispatch.c | 4 +-
src/lxc/lxc_controller.c | 65 ++--
src/rpc/virnetdaemon.c | 749 +++++++++++++++++++++++++++++++++++++
src/rpc/virnetdaemon.h | 82 ++++
src/rpc/virnetserver.c | 520 +++----------------------
src/rpc/virnetserver.h | 46 +--
src/rpc/virnetserverprogram.h | 3 +
15 files changed, 1086 insertions(+), 604 deletions(-)
create mode 100644 src/rpc/virnetdaemon.c
create mode 100644 src/rpc/virnetdaemon.h
diff --git a/daemon/libvirtd.c b/daemon/libvirtd.c
index 1e2c002ebacb..94103e2d0d8c 100644
--- a/daemon/libvirtd.c
+++ b/daemon/libvirtd.c
@@ -1,7 +1,7 @@
/*
* libvirtd.c: daemon start of day, guest process & i/o management
*
- * Copyright (C) 2006-2014 Red Hat, Inc.
+ * Copyright (C) 2006-2015 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
@@ -49,7 +49,7 @@
#include "viralloc.h"
#include "virconf.h"
#include "virnetlink.h"
-#include "virnetserver.h"
+#include "virnetdaemon.h"
#include "remote.h"
#include "virhook.h"
#include "viraudit.h"
@@ -776,14 +776,14 @@ daemonSetupPrivs(void)
#endif
-static void daemonShutdownHandler(virNetServerPtr srv,
+static void daemonShutdownHandler(virNetDaemonPtr dmn,
siginfo_t *sig ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED)
{
- virNetServerQuit(srv);
+ virNetDaemonQuit(dmn);
}
-static void daemonReloadHandler(virNetServerPtr srv ATTRIBUTE_UNUSED,
+static void daemonReloadHandler(virNetDaemonPtr dmn ATTRIBUTE_UNUSED,
siginfo_t *sig ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED)
{
@@ -799,15 +799,15 @@ static void daemonReloadHandler(virNetServerPtr srv ATTRIBUTE_UNUSED,
VIR_WARN("Error while reloading drivers");
}
-static int daemonSetupSignals(virNetServerPtr srv)
+static int daemonSetupSignals(virNetDaemonPtr dmn)
{
- if (virNetServerAddSignalHandler(srv, SIGINT, daemonShutdownHandler, NULL) < 0)
+ if (virNetDaemonAddSignalHandler(dmn, SIGINT, daemonShutdownHandler, NULL) < 0)
return -1;
- if (virNetServerAddSignalHandler(srv, SIGQUIT, daemonShutdownHandler, NULL) < 0)
+ if (virNetDaemonAddSignalHandler(dmn, SIGQUIT, daemonShutdownHandler, NULL) < 0)
return -1;
- if (virNetServerAddSignalHandler(srv, SIGTERM, daemonShutdownHandler, NULL) < 0)
+ if (virNetDaemonAddSignalHandler(dmn, SIGTERM, daemonShutdownHandler, NULL) < 0)
return -1;
- if (virNetServerAddSignalHandler(srv, SIGHUP, daemonReloadHandler, NULL) < 0)
+ if (virNetDaemonAddSignalHandler(dmn, SIGHUP, daemonReloadHandler, NULL) < 0)
return -1;
return 0;
}
@@ -815,12 +815,12 @@ static int daemonSetupSignals(virNetServerPtr srv)
static void daemonInhibitCallback(bool inhibit, void *opaque)
{
- virNetServerPtr srv = opaque;
+ virNetDaemonPtr dmn = opaque;
if (inhibit)
- virNetServerAddShutdownInhibition(srv);
+ virNetDaemonAddShutdownInhibition(dmn);
else
- virNetServerRemoveShutdownInhibition(srv);
+ virNetDaemonRemoveShutdownInhibition(dmn);
}
@@ -830,26 +830,26 @@ static DBusConnection *systemBus;
static void daemonStopWorker(void *opaque)
{
- virNetServerPtr srv = opaque;
+ virNetDaemonPtr dmn = opaque;
- VIR_DEBUG("Begin stop srv=%p", srv);
+ VIR_DEBUG("Begin stop dmn=%p", dmn);
ignore_value(virStateStop());
- VIR_DEBUG("Completed stop srv=%p", srv);
+ VIR_DEBUG("Completed stop dmn=%p", dmn);
/* Exit libvirtd cleanly */
- virNetServerQuit(srv);
+ virNetDaemonQuit(dmn);
}
/* We do this in a thread to not block the main loop */
-static void daemonStop(virNetServerPtr srv)
+static void daemonStop(virNetDaemonPtr dmn)
{
virThread thr;
- virObjectRef(srv);
- if (virThreadCreate(&thr, false, daemonStopWorker, srv) < 0)
- virObjectUnref(srv);
+ virObjectRef(dmn);
+ if (virThreadCreate(&thr, false, daemonStopWorker, dmn) < 0)
+ virObjectUnref(dmn);
}
@@ -858,14 +858,14 @@ handleSessionMessageFunc(DBusConnection *connection ATTRIBUTE_UNUSED,
DBusMessage *message,
void *opaque)
{
- virNetServerPtr srv = opaque;
+ virNetDaemonPtr dmn = opaque;
- VIR_DEBUG("srv=%p", srv);
+ VIR_DEBUG("dmn=%p", dmn);
if (dbus_message_is_signal(message,
DBUS_INTERFACE_LOCAL,
"Disconnected"))
- daemonStop(srv);
+ daemonStop(dmn);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
@@ -876,14 +876,14 @@ handleSystemMessageFunc(DBusConnection *connection ATTRIBUTE_UNUSED,
DBusMessage *message,
void *opaque)
{
- virNetServerPtr srv = opaque;
+ virNetDaemonPtr dmn = opaque;
- VIR_DEBUG("srv=%p", srv);
+ VIR_DEBUG("dmn=%p", dmn);
if (dbus_message_is_signal(message,
"org.freedesktop.login1.Manager",
"PrepareForShutdown"))
- daemonStop(srv);
+ daemonStop(dmn);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
@@ -892,22 +892,22 @@ handleSystemMessageFunc(DBusConnection *connection ATTRIBUTE_UNUSED,
static void daemonRunStateInit(void *opaque)
{
- virNetServerPtr srv = opaque;
+ virNetDaemonPtr dmn = opaque;
virIdentityPtr sysident = virIdentityGetSystem();
virIdentitySetCurrent(sysident);
/* Since driver initialization can take time inhibit daemon shutdown until
we're done so clients get a chance to connect */
- daemonInhibitCallback(true, srv);
+ daemonInhibitCallback(true, dmn);
/* Start the stateful HV drivers
* This is deliberately done after telling the parent process
* we're ready, since it can take a long time and this will
* seriously delay OS bootup process */
- if (virStateInitialize(virNetServerIsPrivileged(srv),
+ if (virStateInitialize(virNetDaemonIsPrivileged(dmn),
daemonInhibitCallback,
- srv) < 0) {
+ dmn) < 0) {
VIR_ERROR(_("Driver state initialization failed"));
/* Ensure the main event loop quits */
kill(getpid(), SIGTERM);
@@ -918,17 +918,17 @@ static void daemonRunStateInit(void *opaque)
#ifdef HAVE_DBUS
/* Tie the non-priviledged libvirtd to the session/shutdown lifecycle */
- if (!virNetServerIsPrivileged(srv)) {
+ if (!virNetDaemonIsPrivileged(dmn)) {
sessionBus = virDBusGetSessionBus();
if (sessionBus != NULL)
dbus_connection_add_filter(sessionBus,
- handleSessionMessageFunc, srv, NULL);
+ handleSessionMessageFunc, dmn, NULL);
systemBus = virDBusGetSystemBus();
if (systemBus != NULL) {
dbus_connection_add_filter(systemBus,
- handleSystemMessageFunc, srv, NULL);
+ handleSystemMessageFunc, dmn, NULL);
dbus_bus_add_match(systemBus,
"type='signal',sender='org.freedesktop.login1', interface='org.freedesktop.login1.Manager'",
NULL);
@@ -936,20 +936,20 @@ static void daemonRunStateInit(void *opaque)
}
#endif
/* Only now accept clients from network */
- virNetServerUpdateServices(srv, true);
+ virNetDaemonUpdateServices(dmn, true);
cleanup:
- daemonInhibitCallback(false, srv);
- virObjectUnref(srv);
+ daemonInhibitCallback(false, dmn);
+ virObjectUnref(dmn);
virObjectUnref(sysident);
virIdentitySetCurrent(NULL);
}
-static int daemonStateInit(virNetServerPtr srv)
+static int daemonStateInit(virNetDaemonPtr dmn)
{
virThread thr;
- virObjectRef(srv);
- if (virThreadCreate(&thr, false, daemonRunStateInit, srv) < 0) {
- virObjectUnref(srv);
+ virObjectRef(dmn);
+ if (virThreadCreate(&thr, false, daemonRunStateInit, dmn) < 0) {
+ virObjectUnref(dmn);
return -1;
}
return 0;
@@ -1100,6 +1100,7 @@ daemonUsage(const char *argv0, bool privileged)
}
int main(int argc, char **argv) {
+ virNetDaemonPtr dmn = NULL;
virNetServerPtr srv = NULL;
char *remote_config_file = NULL;
int statuswrite = -1;
@@ -1354,6 +1355,12 @@ int main(int argc, char **argv) {
goto cleanup;
}
+ if (!(dmn = virNetDaemonNew()) ||
+ virNetDaemonAddServer(dmn, srv) < 0) {
+ ret = VIR_DAEMON_ERR_INIT;
+ goto cleanup;
+ }
+
/* Beyond this point, nothing should rely on using
* getuid/geteuid() == 0, for privilege level checks.
*/
@@ -1408,11 +1415,10 @@ int main(int argc, char **argv) {
if (timeout != -1) {
VIR_DEBUG("Registering shutdown timeout %d", timeout);
- virNetServerAutoShutdown(srv,
- timeout);
+ virNetDaemonAutoShutdown(dmn, timeout);
}
- if ((daemonSetupSignals(srv)) < 0) {
+ if ((daemonSetupSignals(dmn)) < 0) {
ret = VIR_DAEMON_ERR_SIGNAL;
goto cleanup;
}
@@ -1467,7 +1473,7 @@ int main(int argc, char **argv) {
}
/* Initialize drivers & then start accepting new clients from network */
- if (daemonStateInit(srv) < 0) {
+ if (daemonStateInit(dmn) < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
@@ -1489,7 +1495,7 @@ int main(int argc, char **argv) {
#endif
/* Run event loop. */
- virNetServerRun(srv);
+ virNetDaemonRun(dmn);
ret = 0;
@@ -1501,7 +1507,8 @@ int main(int argc, char **argv) {
virObjectUnref(remoteProgram);
virObjectUnref(lxcProgram);
virObjectUnref(qemuProgram);
- virNetServerClose(srv);
+ virNetDaemonClose(dmn);
+ virObjectUnref(dmn);
virObjectUnref(srv);
virNetlinkShutdown();
if (statuswrite != -1) {
diff --git a/docs/internals.html.in b/docs/internals.html.in
index 398d02e649b3..c30f52f9f062 100644
--- a/docs/internals.html.in
+++ b/docs/internals.html.in
@@ -82,7 +82,9 @@
<ul>
<li>Daemon Startup
<p>The daemon initialization processing will declare itself
- as a server via a virNetServerNew() call, then use
+ as a daemon via a virNetDaemonNew() call, then creates new server
+ using virNetServerNew() and adds that server to the main daemon
+ struct with virNetDaemonAddServer() call. It will then use
virDriverLoadModule() to find/load all known drivers,
set up an RPC server program using the <code>remoteProcs[]</code>
table via a virNetServerProgramNew() call. The table is the
diff --git a/docs/internals/rpc.html.in b/docs/internals/rpc.html.in
index f2ed64f1c0e5..a48a4c0d6dc3 100644
--- a/docs/internals/rpc.html.in
+++ b/docs/internals/rpc.html.in
@@ -532,6 +532,13 @@
calls in parallel, with dispatch across multiple worker threads.
</dd>
+ <dt><code>virNetDaemonPtr</code> (virnetdaemon.h)</dt>
+ <dd>The virNetDaemon APIs are used to manage a daemon process. A
+ deamon is a process that might expose one or more servers. It
+ handles most process-related details, network-related should
+ be part of the underlying server.
+ </dd>
+
<dt><code>virNetServerMDNSPtr</code> (virnetservermdns.h)</dt>
<dd>The virNetServerMDNS APIs are used to advertise a server
across the local network, enabling clients to automatically
diff --git a/po/POTFILES.in b/po/POTFILES.in
index bb0f6e154349..ebb048258466 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -132,6 +132,7 @@ src/rpc/virkeepalive.c
src/rpc/virnetclient.c
src/rpc/virnetclientprogram.c
src/rpc/virnetclientstream.c
+src/rpc/virnetdaemon.c
src/rpc/virnetmessage.c
src/rpc/virnetsaslcontext.c
src/rpc/virnetsocket.c
diff --git a/src/Makefile.am b/src/Makefile.am
index a9ebb07b1d32..d71c31876f51 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -2507,6 +2507,7 @@ libvirt_net_rpc_server_la_SOURCES = \
rpc/virnetserverservice.h rpc/virnetserverservice.c \
rpc/virnetserverclient.h rpc/virnetserverclient.c \
rpc/virnetservermdns.h rpc/virnetservermdns.c \
+ rpc/virnetdaemon.h rpc/virnetdaemon.c \
rpc/virnetserver.h rpc/virnetserver.c
libvirt_net_rpc_server_la_CFLAGS = \
$(AVAHI_CFLAGS) \
diff --git a/src/libvirt_remote.syms b/src/libvirt_remote.syms
index bdd68f63e971..e6ca041ea8e1 100644
--- a/src/libvirt_remote.syms
+++ b/src/libvirt_remote.syms
@@ -57,6 +57,24 @@ virNetClientStreamSendPacket;
virNetClientStreamSetError;
+# rpc/virnetdaemon.h
+virNetDaemonAddServer;
+virNetDaemonAddServerPostExec;
+virNetDaemonAddShutdownInhibition;
+virNetDaemonAddSignalHandler;
+virNetDaemonAutoShutdown;
+virNetDaemonClose;
+virNetDaemonGetServer;
+virNetDaemonIsPrivileged;
+virNetDaemonNew;
+virNetDaemonNewPostExecRestart;
+virNetDaemonPreExecRestart;
+virNetDaemonQuit;
+virNetDaemonRemoveShutdownInhibition;
+virNetDaemonRun;
+virNetDaemonUpdateServices;
+
+
# rpc/virnetmessage.h
virNetMessageClear;
virNetMessageDecodeHeader;
@@ -80,18 +98,16 @@ xdr_virNetMessageError;
virNetServerAddClient;
virNetServerAddProgram;
virNetServerAddService;
-virNetServerAddShutdownInhibition;
-virNetServerAddSignalHandler;
-virNetServerAutoShutdown;
virNetServerClose;
-virNetServerIsPrivileged;
+virNetServerHasClients;
virNetServerKeepAliveRequired;
virNetServerNew;
virNetServerNewPostExecRestart;
virNetServerPreExecRestart;
-virNetServerQuit;
-virNetServerRemoveShutdownInhibition;
-virNetServerRun;
+virNetServerProcessClients;
+virNetServerStart;
+virNetServerTrackCompletedAuth;
+virNetServerTrackPendingAuth;
virNetServerUpdateServices;
diff --git a/src/locking/lock_daemon.c b/src/locking/lock_daemon.c
index 042ff947f804..ecbe03a4c154 100644
--- a/src/locking/lock_daemon.c
+++ b/src/locking/lock_daemon.c
@@ -1,7 +1,7 @@
/*
* lock_daemon.c: lock management daemon
*
- * Copyright (C) 2006-2014 Red Hat, Inc.
+ * Copyright (C) 2006-2015 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -41,6 +41,7 @@
#include "virlog.h"
#include "viralloc.h"
#include "virconf.h"
+#include "rpc/virnetdaemon.h"
#include "rpc/virnetserver.h"
#include "virrandom.h"
#include "virhash.h"
@@ -60,6 +61,7 @@ VIR_LOG_INIT("locking.lock_daemon");
struct _virLockDaemon {
virMutex lock;
+ virNetDaemonPtr dmn;
virNetServerPtr srv;
virHashTablePtr lockspaces;
virLockSpacePtr defaultLockspace;
@@ -118,6 +120,7 @@ virLockDaemonFree(virLockDaemonPtr lockd)
return;
virObjectUnref(lockd->srv);
+ virObjectUnref(lockd->dmn);
virHashFree(lockd->lockspaces);
virLockSpaceFree(lockd->defaultLockspace);
@@ -155,6 +158,10 @@ virLockDaemonNew(virLockDaemonConfigPtr config, bool privileged)
(void*)(intptr_t)(privileged ? 0x1 : 0x0))))
goto error;
+ if (!(lockd->dmn = virNetDaemonNew()) ||
+ virNetDaemonAddServer(lockd->dmn, lockd->srv) < 0)
+ goto error;
+
if (!(lockd->lockspaces = virHashCreate(VIR_LOCK_DAEMON_NUM_LOCKSPACES,
virLockDaemonLockSpaceDataFree)))
goto error;
@@ -230,18 +237,29 @@ virLockDaemonNewPostExecRestart(virJSONValuePtr object, bool privileged)
}
}
- if (!(child = virJSONValueObjectGet(object, "server"))) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Missing server data from JSON file"));
- goto error;
+ if (virJSONValueObjectHasKey(object, "daemon")) {
+ if (!(child = virJSONValueObjectGet(object, "daemon"))) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Malformed daemon data from JSON file"));
+ goto error;
+ }
+ } else {
+ if (!(child = virJSONValueObjectGet(object, "server"))) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Missing server data from JSON file"));
+ goto error;
+ }
}
- if (!(lockd->srv = virNetServerNewPostExecRestart(child,
- virLockDaemonClientNew,
- virLockDaemonClientNewPostExecRestart,
- virLockDaemonClientPreExecRestart,
- virLockDaemonClientFree,
- (void*)(intptr_t)(privileged ? 0x1 : 0x0))))
+ if (!(lockd->dmn = virNetDaemonNewPostExecRestart(child)))
+ goto error;
+
+ if (!(lockd->srv = virNetDaemonAddServerPostExec(lockd->dmn,
+ virLockDaemonClientNew,
+ virLockDaemonClientNewPostExecRestart,
+ virLockDaemonClientPreExecRestart,
+ virLockDaemonClientFree,
+ (void*)(intptr_t)(privileged ? 0x1 : 0x0))))
goto error;
return lockd;
@@ -529,32 +547,32 @@ virLockDaemonVersion(const char *argv0)
}
static void
-virLockDaemonShutdownHandler(virNetServerPtr srv,
+virLockDaemonShutdownHandler(virNetDaemonPtr dmn,
siginfo_t *sig ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED)
{
- virNetServerQuit(srv);
+ virNetDaemonQuit(dmn);
}
static void
-virLockDaemonExecRestartHandler(virNetServerPtr srv,
+virLockDaemonExecRestartHandler(virNetDaemonPtr dmn,
siginfo_t *sig ATTRIBUTE_UNUSED,
void *opaque ATTRIBUTE_UNUSED)
{
execRestart = true;
- virNetServerQuit(srv);
+ virNetDaemonQuit(dmn);
}
static int
-virLockDaemonSetupSignals(virNetServerPtr srv)
+virLockDaemonSetupSignals(virNetDaemonPtr dmn)
{
- if (virNetServerAddSignalHandler(srv, SIGINT, virLockDaemonShutdownHandler, NULL) < 0)
+ if (virNetDaemonAddSignalHandler(dmn, SIGINT, virLockDaemonShutdownHandler, NULL) < 0)
return -1;
- if (virNetServerAddSignalHandler(srv, SIGQUIT, virLockDaemonShutdownHandler, NULL) < 0)
+ if (virNetDaemonAddSignalHandler(dmn, SIGQUIT, virLockDaemonShutdownHandler, NULL) < 0)
return -1;
- if (virNetServerAddSignalHandler(srv, SIGTERM, virLockDaemonShutdownHandler, NULL) < 0)
+ if (virNetDaemonAddSignalHandler(dmn, SIGTERM, virLockDaemonShutdownHandler, NULL) < 0)
return -1;
- if (virNetServerAddSignalHandler(srv, SIGUSR1, virLockDaemonExecRestartHandler, NULL) < 0)
+ if (virNetDaemonAddSignalHandler(dmn, SIGUSR1, virLockDaemonExecRestartHandler, NULL) < 0)
return -1;
return 0;
}
@@ -966,7 +984,7 @@ virLockDaemonPostExecRestart(const char *state_file,
static int
virLockDaemonPreExecRestart(const char *state_file,
- virNetServerPtr srv,
+ virNetDaemonPtr dmn,
char **argv)
{
virJSONValuePtr child;
@@ -982,10 +1000,10 @@ virLockDaemonPreExecRestart(const char *state_file,
if (!(object = virJSONValueNewObject()))
goto cleanup;
- if (!(child = virNetServerPreExecRestart(srv)))
+ if (!(child = virNetDaemonPreExecRestart(dmn)))
goto cleanup;
- if (virJSONValueObjectAppend(object, "server", child) < 0) {
+ if (virJSONValueObjectAppend(object, "daemon", child) < 0) {
virJSONValueFree(child);
goto cleanup;
}
@@ -1350,11 +1368,11 @@ int main(int argc, char **argv) {
if (timeout != -1) {
VIR_DEBUG("Registering shutdown timeout %d", timeout);
- virNetServerAutoShutdown(lockDaemon->srv,
+ virNetDaemonAutoShutdown(lockDaemon->dmn,
timeout);
}
- if ((virLockDaemonSetupSignals(lockDaemon->srv)) < 0) {
+ if ((virLockDaemonSetupSignals(lockDaemon->dmn)) < 0) {
ret = VIR_LOCK_DAEMON_ERR_SIGNAL;
goto cleanup;
}
@@ -1366,6 +1384,7 @@ int main(int argc, char **argv) {
ret = VIR_LOCK_DAEMON_ERR_INIT;
goto cleanup;
}
+
if (virNetServerAddProgram(lockDaemon->srv, lockProgram) < 0) {
ret = VIR_LOCK_DAEMON_ERR_INIT;
goto cleanup;
@@ -1389,12 +1408,12 @@ int main(int argc, char **argv) {
/* Start accepting new clients from network */
- virNetServerUpdateServices(lockDaemon->srv, true);
- virNetServerRun(lockDaemon->srv);
+ virNetDaemonUpdateServices(lockDaemon->dmn, true);
+ virNetDaemonRun(lockDaemon->dmn);
if (execRestart &&
virLockDaemonPreExecRestart(state_file,
- lockDaemon->srv,
+ lockDaemon->dmn,
argv) < 0)
ret = VIR_LOCK_DAEMON_ERR_REEXEC;
else
diff --git a/src/locking/lock_daemon_config.c b/src/locking/lock_daemon_config.c
index 8a6d18f93598..106e82059ee3 100644
--- a/src/locking/lock_daemon_config.c
+++ b/src/locking/lock_daemon_config.c
@@ -28,7 +28,7 @@
#include "viralloc.h"
#include "virerror.h"
#include "virlog.h"
-#include "rpc/virnetserver.h"
+#include "rpc/virnetdaemon.h"
#include "configmake.h"
#include "virstring.h"
#include "virutil.h"
diff --git a/src/locking/lock_daemon_dispatch.c b/src/locking/lock_daemon_dispatch.c
index bad646c6d07b..1b479db55dd4 100644
--- a/src/locking/lock_daemon_dispatch.c
+++ b/src/locking/lock_daemon_dispatch.c
@@ -1,7 +1,7 @@
/*
* lock_daemon_dispatch.c: lock management daemon dispatch
*
- * Copyright (C) 2006-2012 Red Hat, Inc.
+ * Copyright (C) 2006-2015 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -22,7 +22,7 @@
#include <config.h>
-#include "rpc/virnetserver.h"
+#include "rpc/virnetdaemon.h"
#include "rpc/virnetserverclient.h"
#include "virlog.h"
#include "virstring.h"
diff --git a/src/lxc/lxc_controller.c b/src/lxc/lxc_controller.c
index efbe71feac1d..f456d1f74fe0 100644
--- a/src/lxc/lxc_controller.c
+++ b/src/lxc/lxc_controller.c
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2010-2014 Red Hat, Inc.
+ * Copyright (C) 2010-2015 Red Hat, Inc.
* Copyright IBM Corp. 2008
*
* lxc_controller.c: linux container process controller
@@ -65,7 +65,7 @@
#include "virprocess.h"
#include "virnuma.h"
#include "virdbus.h"
-#include "rpc/virnetserver.h"
+#include "rpc/virnetdaemon.h"
#include "virstring.h"
#define VIR_FROM_THIS VIR_FROM_LXC
@@ -93,7 +93,7 @@ struct _virLXCControllerConsole {
size_t fromContLen;
char fromContBuf[1024];
- virNetServerPtr server;
+ virNetDaemonPtr daemon;
};
typedef struct _virLXCController virLXCController;
@@ -125,8 +125,7 @@ struct _virLXCController {
virSecurityManagerPtr securityManager;
- /* Server socket */
- virNetServerPtr server;
+ virNetDaemonPtr daemon;
bool firstClient;
virNetServerClientPtr client;
virNetServerProgramPtr prog;
@@ -149,7 +148,7 @@ static void virLXCControllerQuitTimer(int timer ATTRIBUTE_UNUSED, void *opaque)
virLXCControllerPtr ctrl = opaque;
VIR_DEBUG("Triggering event loop quit");
- virNetServerQuit(ctrl->server);
+ virNetDaemonQuit(ctrl->daemon);
}
@@ -280,7 +279,7 @@ static void virLXCControllerFree(virLXCControllerPtr ctrl)
if (ctrl->timerShutdown != -1)
virEventRemoveTimeout(ctrl->timerShutdown);
- virObjectUnref(ctrl->server);
+ virObjectUnref(ctrl->daemon);
virLXCControllerFreeFuse(ctrl);
virCgroupFree(&ctrl->cgroup);
@@ -296,7 +295,7 @@ static int virLXCControllerAddConsole(virLXCControllerPtr ctrl,
{
if (VIR_EXPAND_N(ctrl->consoles, ctrl->nconsoles, 1) < 0)
return -1;
- ctrl->consoles[ctrl->nconsoles-1].server = ctrl->server;
+ ctrl->consoles[ctrl->nconsoles-1].daemon = ctrl->daemon;
ctrl->consoles[ctrl->nconsoles-1].hostFd = hostFd;
ctrl->consoles[ctrl->nconsoles-1].hostWatch = -1;
@@ -846,6 +845,7 @@ static void *virLXCControllerClientPrivateNew(virNetServerClientPtr client,
static int virLXCControllerSetupServer(virLXCControllerPtr ctrl)
{
+ virNetServerPtr srv = NULL;
virNetServerServicePtr svc = NULL;
char *sockpath;
@@ -853,13 +853,13 @@ static int virLXCControllerSetupServer(virLXCControllerPtr ctrl)
LXC_STATE_DIR, ctrl->name) < 0)
return -1;
- if (!(ctrl->server = virNetServerNew(0, 0, 0, 1,
- 0, -1, 0, false,
- NULL,
- virLXCControllerClientPrivateNew,
- NULL,
- virLXCControllerClientPrivateFree,
- ctrl)))
+ if (!(srv = virNetServerNew(0, 0, 0, 1,
+ 0, -1, 0, false,
+ NULL,
+ virLXCControllerClientPrivateNew,
+ NULL,
+ virLXCControllerClientPrivateFree,
+ ctrl)))
goto error;
if (virSecurityManagerSetSocketLabel(ctrl->securityManager, ctrl->def) < 0)
@@ -880,7 +880,7 @@ static int virLXCControllerSetupServer(virLXCControllerPtr ctrl)
if (virSecurityManagerClearSocketLabel(ctrl->securityManager, ctrl->def) < 0)
goto error;
- if (virNetServerAddService(ctrl->server, svc, NULL) < 0)
+ if (virNetServerAddService(srv, svc, NULL) < 0)
goto error;
virObjectUnref(svc);
svc = NULL;
@@ -891,14 +891,19 @@ static int virLXCControllerSetupServer(virLXCControllerPtr ctrl)
virLXCMonitorNProcs)))
goto error;
- virNetServerUpdateServices(ctrl->server, true);
+ if (!(ctrl->daemon = virNetDaemonNew()) ||
+ virNetDaemonAddServer(ctrl->daemon, srv) < 0)
+ goto error;
+
+ virNetDaemonUpdateServices(ctrl->daemon, true);
VIR_FREE(sockpath);
return 0;
error:
VIR_FREE(sockpath);
- virObjectUnref(ctrl->server);
- ctrl->server = NULL;
+ virObjectUnref(srv);
+ virObjectUnref(ctrl->daemon);
+ ctrl->daemon = NULL;
virObjectUnref(svc);
return -1;
}
@@ -926,7 +931,7 @@ static bool wantReboot;
static virMutex lock = VIR_MUTEX_INITIALIZER;
-static void virLXCControllerSignalChildIO(virNetServerPtr server,
+static void virLXCControllerSignalChildIO(virNetDaemonPtr daemon,
siginfo_t *info ATTRIBUTE_UNUSED,
void *opaque)
{
@@ -937,7 +942,7 @@ static void virLXCControllerSignalChildIO(virNetServerPtr server,
ret = waitpid(-1, &status, WNOHANG);
VIR_DEBUG("Got sig child %d vs %lld", ret, (unsigned long long)ctrl->initpid);
if (ret == ctrl->initpid) {
- virNetServerQuit(server);
+ virNetDaemonQuit(daemon);
virMutexLock(&lock);
if (WIFSIGNALED(status) &&
WTERMSIG(status) == SIGHUP) {
@@ -996,7 +1001,7 @@ static void virLXCControllerConsoleUpdateWatch(virLXCControllerConsolePtr consol
VIR_DEBUG(":fail");
virReportSystemError(errno, "%s",
_("Unable to add epoll fd"));
- virNetServerQuit(console->server);
+ virNetDaemonQuit(console->daemon);
goto cleanup;
}
console->hostEpoll = events;
@@ -1008,7 +1013,7 @@ static void virLXCControllerConsoleUpdateWatch(virLXCControllerConsolePtr consol
virReportSystemError(errno, "%s",
_("Unable to remove epoll fd"));
VIR_DEBUG(":fail");
- virNetServerQuit(console->server);
+ virNetDaemonQuit(console->daemon);
goto cleanup;
}
console->hostEpoll = 0;
@@ -1034,7 +1039,7 @@ static void virLXCControllerConsoleUpdateWatch(virLXCControllerConsolePtr consol
virReportSystemError(errno, "%s",
_("Unable to add epoll fd"));
VIR_DEBUG(":fail");
- virNetServerQuit(console->server);
+ virNetDaemonQuit(console->daemon);
goto cleanup;
}
console->contEpoll = events;
@@ -1046,7 +1051,7 @@ static void virLXCControllerConsoleUpdateWatch(virLXCControllerConsolePtr consol
virReportSystemError(errno, "%s",
_("Unable to remove epoll fd"));
VIR_DEBUG(":fail");
- virNetServerQuit(console->server);
+ virNetDaemonQuit(console->daemon);
goto cleanup;
}
console->contEpoll = 0;
@@ -1075,7 +1080,7 @@ static void virLXCControllerConsoleEPoll(int watch, int fd, int events, void *op
continue;
virReportSystemError(errno, "%s",
_("Unable to wait on epoll"));
- virNetServerQuit(console->server);
+ virNetDaemonQuit(console->daemon);
goto cleanup;
}
@@ -1188,7 +1193,7 @@ static void virLXCControllerConsoleIO(int watch, int fd, int events, void *opaqu
virEventRemoveHandle(console->contWatch);
virEventRemoveHandle(console->hostWatch);
console->contWatch = console->hostWatch = -1;
- virNetServerQuit(console->server);
+ virNetDaemonQuit(console->daemon);
virMutexUnlock(&lock);
}
@@ -1208,7 +1213,7 @@ static int virLXCControllerMain(virLXCControllerPtr ctrl)
int rc = -1;
size_t i;
- if (virNetServerAddSignalHandler(ctrl->server,
+ if (virNetDaemonAddSignalHandler(ctrl->daemon,
SIGCHLD,
virLXCControllerSignalChildIO,
ctrl) < 0)
@@ -1254,7 +1259,7 @@ static int virLXCControllerMain(virLXCControllerPtr ctrl)
}
}
- virNetServerRun(ctrl->server);
+ virNetDaemonRun(ctrl->daemon);
err = virGetLastError();
if (!err || err->code == VIR_ERR_OK)
@@ -2228,7 +2233,7 @@ virLXCControllerEventSendExit(virLXCControllerPtr ctrl,
VIR_DEBUG("Waiting for client to complete dispatch");
ctrl->inShutdown = true;
virNetServerClientDelayedClose(ctrl->client);
- virNetServerRun(ctrl->server);
+ virNetDaemonRun(ctrl->daemon);
}
VIR_DEBUG("Client has gone away");
return 0;
diff --git a/src/rpc/virnetdaemon.c b/src/rpc/virnetdaemon.c
new file mode 100644
index 000000000000..a6d6a4bd8446
--- /dev/null
+++ b/src/rpc/virnetdaemon.c
@@ -0,0 +1,749 @@
+/*
+ * virnetdaemon.c
+ *
+ * Copyright (C) 2015 Red Hat, Inc.
+ *
+ * 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@xxxxxxxxxx>
+ */
+
+#include <config.h>
+
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "virnetdaemon.h"
+#include "virlog.h"
+#include "viralloc.h"
+#include "virerror.h"
+#include "virthread.h"
+#include "virthreadpool.h"
+#include "virutil.h"
+#include "virfile.h"
+#include "virnetserver.h"
+#include "virnetservermdns.h"
+#include "virdbus.h"
+#include "virstring.h"
+#include "virsystemd.h"
+
+#ifndef SA_SIGINFO
+# define SA_SIGINFO 0
+#endif
+
+#define VIR_FROM_THIS VIR_FROM_RPC
+
+VIR_LOG_INIT("rpc.netserver");
+
+typedef struct _virNetDaemonSignal virNetDaemonSignal;
+typedef virNetDaemonSignal *virNetDaemonSignalPtr;
+
+struct _virNetDaemonSignal {
+ struct sigaction oldaction;
+ int signum;
+ virNetDaemonSignalFunc func;
+ void *opaque;
+};
+
+struct _virNetDaemon {
+ virObjectLockable parent;
+
+ bool privileged;
+
+ size_t nsignals;
+ virNetDaemonSignalPtr *signals;
+ int sigread;
+ int sigwrite;
+ int sigwatch;
+
+ size_t nservers;
+ virNetServerPtr *servers;
+ virJSONValuePtr srvObject;
+
+ bool quit;
+
+ unsigned int autoShutdownTimeout;
+ size_t autoShutdownInhibitions;
+ bool autoShutdownCallingInhibit;
+ int autoShutdownInhibitFd;
+};
+
+
+static virClassPtr virNetDaemonClass;
+
+static void
+virNetDaemonDispose(void *obj)
+{
+ virNetDaemonPtr dmn = obj;
+ size_t i;
+
+ VIR_FORCE_CLOSE(dmn->autoShutdownInhibitFd);
+
+ for (i = 0; i < dmn->nsignals; i++) {
+ sigaction(dmn->signals[i]->signum, &dmn->signals[i]->oldaction, NULL);
+ VIR_FREE(dmn->signals[i]);
+ }
+ VIR_FREE(dmn->signals);
+ VIR_FORCE_CLOSE(dmn->sigread);
+ VIR_FORCE_CLOSE(dmn->sigwrite);
+ if (dmn->sigwatch > 0)
+ virEventRemoveHandle(dmn->sigwatch);
+
+ for (i = 0; i < dmn->nservers; i++)
+ virObjectUnref(dmn->servers[i]);
+ VIR_FREE(dmn->servers);
+
+ virJSONValueFree(dmn->srvObject);
+}
+
+static int
+virNetDaemonOnceInit(void)
+{
+ if (!(virNetDaemonClass = virClassNew(virClassForObjectLockable(),
+ "virNetDaemon",
+ sizeof(virNetDaemon),
+ virNetDaemonDispose)))
+ return -1;
+
+ return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(virNetDaemon)
+
+
+virNetDaemonPtr
+virNetDaemonNew(void)
+{
+ virNetDaemonPtr dmn;
+ struct sigaction sig_action;
+
+ if (virNetDaemonInitialize() < 0)
+ return NULL;
+
+ if (!(dmn = virObjectLockableNew(virNetDaemonClass)))
+ return NULL;
+
+ dmn->sigwrite = dmn->sigread = -1;
+ dmn->privileged = geteuid() == 0;
+ dmn->autoShutdownInhibitFd = -1;
+
+ if (virEventRegisterDefaultImpl() < 0)
+ goto error;
+
+ memset(&sig_action, 0, sizeof(sig_action));
+ sig_action.sa_handler = SIG_IGN;
+ sigaction(SIGPIPE, &sig_action, NULL);
+
+ return dmn;
+
+ error:
+ virObjectUnref(dmn);
+ return NULL;
+}
+
+
+int
+virNetDaemonAddServer(virNetDaemonPtr dmn, virNetServerPtr srv)
+{
+ int ret = -1;
+
+ virObjectLock(dmn);
+
+ if (VIR_APPEND_ELEMENT(dmn->servers, dmn->nservers, srv) < 0)
+ goto cleanup;
+
+ virObjectRef(srv);
+ ret = dmn->nservers - 1;
+ cleanup:
+ virObjectUnlock(dmn);
+ return ret;
+}
+
+
+/*
+ * Separate function merely for the purpose of unified error
+ * reporting.
+ */
+static virNetServerPtr
+virNetDaemonGetServerInternal(virNetDaemonPtr dmn,
+ int subServerID)
+{
+ if (subServerID < 0 || subServerID >= dmn->nservers) {
+ virReportError(VIR_ERR_INVALID_ARG,
+ _("Invalid server ID: %d"),
+ subServerID);
+ return NULL;
+ }
+
+ return virObjectRef(dmn->servers[subServerID]);
+}
+
+virNetServerPtr
+virNetDaemonGetServer(virNetDaemonPtr dmn,
+ int subServerID)
+{
+ virNetServerPtr srv = NULL;
+
+ virObjectLock(dmn);
+ srv = virNetDaemonGetServerInternal(dmn, subServerID);
+ virObjectUnlock(dmn);
+
+ return srv;
+}
+
+virNetServerPtr
+virNetDaemonAddServerPostExec(virNetDaemonPtr dmn,
+ virNetServerClientPrivNew clientPrivNew,
+ virNetServerClientPrivNewPostExecRestart clientPrivNewPostExecRestart,
+ virNetServerClientPrivPreExecRestart clientPrivPreExecRestart,
+ virFreeCallback clientPrivFree,
+ void *clientPrivOpaque)
+{
+ virJSONValuePtr object = NULL;
+ virNetServerPtr srv = NULL;
+
+ virObjectLock(dmn);
+
+ if (!dmn->srvObject) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Cannot add more servers post-exec than "
+ "there were pre-exec"));
+ goto error;
+ }
+
+ if (virJSONValueIsArray(dmn->srvObject)) {
+ object = virJSONValueArraySteal(dmn->srvObject, 0);
+ if (virJSONValueArraySize(dmn->srvObject) == 0) {
+ virJSONValueFree(dmn->srvObject);
+ dmn->srvObject = NULL;
+ }
+ } else {
+ object = dmn->srvObject;
+ dmn->srvObject = NULL;
+ }
+
+ srv = virNetServerNewPostExecRestart(object,
+ clientPrivNew,
+ clientPrivNewPostExecRestart,
+ clientPrivPreExecRestart,
+ clientPrivFree,
+ clientPrivOpaque);
+
+ if (!srv || VIR_APPEND_ELEMENT_COPY(dmn->servers, dmn->nservers, srv) < 0)
+ goto error;
+
+ virJSONValueFree(object);
+ virObjectUnlock(dmn);
+ return srv;
+
+ error:
+ virObjectUnlock(dmn);
+ virObjectUnref(srv);
+ virJSONValueFree(object);
+ return NULL;
+}
+
+
+virNetDaemonPtr
+virNetDaemonNewPostExecRestart(virJSONValuePtr object)
+{
+ virNetDaemonPtr dmn = NULL;
+ virJSONValuePtr servers = virJSONValueObjectGet(object, "servers");
+ bool new_version = virJSONValueObjectHasKey(object, "servers");
+
+ if (!(dmn = virNetDaemonNew()))
+ goto error;
+
+ if (new_version && !servers) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Malformed servers data in JSON document"));
+ goto error;
+ }
+
+ if (!(dmn->srvObject = virJSONValueCopy(new_version ? servers : object)))
+ goto error;
+
+ return dmn;
+ error:
+ virObjectUnref(dmn);
+ return NULL;
+}
+
+
+virJSONValuePtr
+virNetDaemonPreExecRestart(virNetDaemonPtr dmn)
+{
+ virJSONValuePtr object, srvArray = NULL;
+ size_t i;
+
+ virObjectLock(dmn);
+
+ if (!(object = virJSONValueNewObject()))
+ goto error;
+
+ if (!(srvArray = virJSONValueNewArray()) ||
+ virJSONValueObjectAppend(object, "servers", srvArray) < 0)
+ goto error;
+
+ for (i = 0; i < dmn->nservers; i++) {
+ virJSONValuePtr srvJSON = NULL;
+ srvJSON = virNetServerPreExecRestart(dmn->servers[i]);
+
+ if (!srvJSON)
+ goto error;
+
+ if (virJSONValueArrayAppend(srvArray, srvJSON) < 0) {
+ virJSONValueFree(srvJSON);
+ goto error;
+ }
+ }
+
+ virObjectUnlock(dmn);
+
+ return object;
+
+ error:
+ virJSONValueFree(object);
+ virJSONValueFree(srvArray);
+ virObjectUnlock(dmn);
+ return NULL;
+}
+
+
+bool
+virNetDaemonIsPrivileged(virNetDaemonPtr dmn)
+{
+ bool priv;
+ virObjectLock(dmn);
+ priv = dmn->privileged;
+ virObjectUnlock(dmn);
+ return priv;
+}
+
+
+void
+virNetDaemonAutoShutdown(virNetDaemonPtr dmn,
+ unsigned int timeout)
+{
+ virObjectLock(dmn);
+
+ dmn->autoShutdownTimeout = timeout;
+
+ virObjectUnlock(dmn);
+}
+
+
+#if defined(HAVE_DBUS) && defined(DBUS_TYPE_UNIX_FD)
+static void
+virNetDaemonGotInhibitReply(DBusPendingCall *pending,
+ void *opaque)
+{
+ virNetDaemonPtr dmn = opaque;
+ DBusMessage *reply;
+ int fd;
+
+ virObjectLock(dmn);
+ dmn->autoShutdownCallingInhibit = false;
+
+ VIR_DEBUG("dmn=%p", dmn);
+
+ reply = dbus_pending_call_steal_reply(pending);
+ if (reply == NULL)
+ goto cleanup;
+
+ if (dbus_message_get_args(reply, NULL,
+ DBUS_TYPE_UNIX_FD, &fd,
+ DBUS_TYPE_INVALID)) {
+ if (dmn->autoShutdownInhibitions) {
+ dmn->autoShutdownInhibitFd = fd;
+ } else {
+ /* We stopped the last VM since we made the inhibit call */
+ VIR_FORCE_CLOSE(fd);
+ }
+ }
+ dbus_message_unref(reply);
+
+ cleanup:
+ virObjectUnlock(dmn);
+}
+
+
+/* As per: http://www.freedesktop.org/wiki/Software/systemd/inhibit */
+static void
+virNetDaemonCallInhibit(virNetDaemonPtr dmn,
+ const char *what,
+ const char *who,
+ const char *why,
+ const char *mode)
+{
+ DBusMessage *message;
+ DBusPendingCall *pendingReply;
+ DBusConnection *systemBus;
+
+ VIR_DEBUG("dmn=%p what=%s who=%s why=%s mode=%s",
+ dmn, NULLSTR(what), NULLSTR(who), NULLSTR(why), NULLSTR(mode));
+
+ if (!(systemBus = virDBusGetSystemBus()))
+ return;
+
+ /* Only one outstanding call at a time */
+ if (dmn->autoShutdownCallingInhibit)
+ return;
+
+ message = dbus_message_new_method_call("org.freedesktop.login1",
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ "Inhibit");
+ if (message == NULL)
+ return;
+
+ dbus_message_append_args(message,
+ DBUS_TYPE_STRING, &what,
+ DBUS_TYPE_STRING, &who,
+ DBUS_TYPE_STRING, &why,
+ DBUS_TYPE_STRING, &mode,
+ DBUS_TYPE_INVALID);
+
+ pendingReply = NULL;
+ if (dbus_connection_send_with_reply(systemBus, message,
+ &pendingReply,
+ 25*1000)) {
+ dbus_pending_call_set_notify(pendingReply,
+ virNetDaemonGotInhibitReply,
+ dmn, NULL);
+ dmn->autoShutdownCallingInhibit = true;
+ }
+ dbus_message_unref(message);
+}
+#endif
+
+void
+virNetDaemonAddShutdownInhibition(virNetDaemonPtr dmn)
+{
+ virObjectLock(dmn);
+ dmn->autoShutdownInhibitions++;
+
+ VIR_DEBUG("dmn=%p inhibitions=%zu", dmn, dmn->autoShutdownInhibitions);
+
+#if defined(HAVE_DBUS) && defined(DBUS_TYPE_UNIX_FD)
+ if (dmn->autoShutdownInhibitions == 1)
+ virNetDaemonCallInhibit(dmn,
+ "shutdown",
+ _("Libvirt"),
+ _("Virtual machines need to be saved"),
+ "delay");
+#endif
+
+ virObjectUnlock(dmn);
+}
+
+
+void
+virNetDaemonRemoveShutdownInhibition(virNetDaemonPtr dmn)
+{
+ virObjectLock(dmn);
+ dmn->autoShutdownInhibitions--;
+
+ VIR_DEBUG("dmn=%p inhibitions=%zu", dmn, dmn->autoShutdownInhibitions);
+
+ if (dmn->autoShutdownInhibitions == 0)
+ VIR_FORCE_CLOSE(dmn->autoShutdownInhibitFd);
+
+ virObjectUnlock(dmn);
+}
+
+
+
+static sig_atomic_t sigErrors;
+static int sigLastErrno;
+static int sigWrite = -1;
+
+static void
+virNetDaemonSignalHandler(int sig, siginfo_t * siginfo,
+ void* context ATTRIBUTE_UNUSED)
+{
+ int origerrno;
+ int r;
+ siginfo_t tmp;
+
+ if (SA_SIGINFO)
+ tmp = *siginfo;
+ else
+ memset(&tmp, 0, sizeof(tmp));
+
+ /* set the sig num in the struct */
+ tmp.si_signo = sig;
+
+ origerrno = errno;
+ r = safewrite(sigWrite, &tmp, sizeof(tmp));
+ if (r == -1) {
+ sigErrors++;
+ sigLastErrno = errno;
+ }
+ errno = origerrno;
+}
+
+static void
+virNetDaemonSignalEvent(int watch,
+ int fd ATTRIBUTE_UNUSED,
+ int events ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ virNetDaemonPtr dmn = opaque;
+ siginfo_t siginfo;
+ size_t i;
+
+ virObjectLock(dmn);
+
+ if (saferead(dmn->sigread, &siginfo, sizeof(siginfo)) != sizeof(siginfo)) {
+ virReportSystemError(errno, "%s",
+ _("Failed to read from signal pipe"));
+ virEventRemoveHandle(watch);
+ dmn->sigwatch = -1;
+ goto cleanup;
+ }
+
+ for (i = 0; i < dmn->nsignals; i++) {
+ if (siginfo.si_signo == dmn->signals[i]->signum) {
+ virNetDaemonSignalFunc func = dmn->signals[i]->func;
+ void *funcopaque = dmn->signals[i]->opaque;
+ virObjectUnlock(dmn);
+ func(dmn, &siginfo, funcopaque);
+ return;
+ }
+ }
+
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Unexpected signal received: %d"), siginfo.si_signo);
+
+ cleanup:
+ virObjectUnlock(dmn);
+}
+
+static int
+virNetDaemonSignalSetup(virNetDaemonPtr dmn)
+{
+ int fds[2] = { -1, -1 };
+
+ if (dmn->sigwrite != -1)
+ return 0;
+
+ if (pipe2(fds, O_CLOEXEC|O_NONBLOCK) < 0) {
+ virReportSystemError(errno, "%s",
+ _("Unable to create signal pipe"));
+ return -1;
+ }
+
+ if ((dmn->sigwatch = virEventAddHandle(fds[0],
+ VIR_EVENT_HANDLE_READABLE,
+ virNetDaemonSignalEvent,
+ dmn, NULL)) < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Failed to add signal handle watch"));
+ goto error;
+ }
+
+ dmn->sigread = fds[0];
+ dmn->sigwrite = fds[1];
+ sigWrite = fds[1];
+
+ return 0;
+
+ error:
+ VIR_FORCE_CLOSE(fds[0]);
+ VIR_FORCE_CLOSE(fds[1]);
+ return -1;
+}
+
+int
+virNetDaemonAddSignalHandler(virNetDaemonPtr dmn,
+ int signum,
+ virNetDaemonSignalFunc func,
+ void *opaque)
+{
+ virNetDaemonSignalPtr sigdata = NULL;
+ struct sigaction sig_action;
+
+ virObjectLock(dmn);
+
+ if (virNetDaemonSignalSetup(dmn) < 0)
+ goto error;
+
+ if (VIR_EXPAND_N(dmn->signals, dmn->nsignals, 1) < 0)
+ goto error;
+
+ if (VIR_ALLOC(sigdata) < 0)
+ goto error;
+
+ sigdata->signum = signum;
+ sigdata->func = func;
+ sigdata->opaque = opaque;
+
+ memset(&sig_action, 0, sizeof(sig_action));
+ sig_action.sa_sigaction = virNetDaemonSignalHandler;
+ sig_action.sa_flags = SA_SIGINFO;
+ sigemptyset(&sig_action.sa_mask);
+
+ sigaction(signum, &sig_action, &sigdata->oldaction);
+
+ dmn->signals[dmn->nsignals-1] = sigdata;
+
+ virObjectUnlock(dmn);
+ return 0;
+
+ error:
+ VIR_FREE(sigdata);
+ virObjectUnlock(dmn);
+ return -1;
+}
+
+
+static void
+virNetDaemonAutoShutdownTimer(int timerid ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ virNetDaemonPtr dmn = opaque;
+
+ virObjectLock(dmn);
+
+ if (!dmn->autoShutdownInhibitions) {
+ VIR_DEBUG("Automatic shutdown triggered");
+ dmn->quit = true;
+ }
+
+ virObjectUnlock(dmn);
+}
+
+void
+virNetDaemonUpdateServices(virNetDaemonPtr dmn,
+ bool enabled)
+{
+ size_t i;
+
+ virObjectLock(dmn);
+ for (i = 0; i < dmn->nservers; i++)
+ virNetServerUpdateServices(dmn->servers[i], enabled);
+ virObjectUnlock(dmn);
+}
+
+void
+virNetDaemonRun(virNetDaemonPtr dmn)
+{
+ int timerid = -1;
+ bool timerActive = false;
+ size_t i;
+
+ virObjectLock(dmn);
+
+ if (dmn->srvObject) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Not all servers restored, cannot run server"));
+ goto cleanup;
+ }
+
+ for (i = 0; i < dmn->nservers; i++) {
+ if (virNetServerStart(dmn->servers[i]) < 0)
+ goto cleanup;
+ }
+
+ dmn->quit = false;
+
+ if (dmn->autoShutdownTimeout &&
+ (timerid = virEventAddTimeout(-1,
+ virNetDaemonAutoShutdownTimer,
+ dmn, NULL)) < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Failed to register shutdown timeout"));
+ goto cleanup;
+ }
+
+ /* We are accepting connections now. Notify systemd
+ * so it can start dependent services. */
+ virSystemdNotifyStartup();
+
+ VIR_DEBUG("dmn=%p quit=%d", dmn, dmn->quit);
+ while (!dmn->quit) {
+ /* A shutdown timeout is specified, so check
+ * if any drivers have active state, if not
+ * shutdown after timeout seconds
+ */
+ if (dmn->autoShutdownTimeout) {
+ if (timerActive) {
+ for (i = 0; i < dmn->nservers; i++) {
+ if (virNetServerHasClients(dmn->servers[i])) {
+ VIR_DEBUG("Deactivating shutdown timer %d", timerid);
+ virEventUpdateTimeout(timerid, -1);
+ timerActive = false;
+ break;
+ }
+ }
+ } else {
+ for (i = 0; i < dmn->nservers; i++) {
+ if (!virNetServerHasClients(dmn->servers[i])) {
+ VIR_DEBUG("Activating shutdown timer %d", timerid);
+ virEventUpdateTimeout(timerid,
+ dmn->autoShutdownTimeout * 1000);
+ timerActive = true;
+ break;
+ }
+ }
+ }
+ }
+
+ virObjectUnlock(dmn);
+ if (virEventRunDefaultImpl() < 0) {
+ virObjectLock(dmn);
+ VIR_DEBUG("Loop iteration error, exiting");
+ break;
+ }
+ virObjectLock(dmn);
+
+ for (i = 0; i < dmn->nservers; i++)
+ virNetServerProcessClients(dmn->servers[i]);
+ }
+
+ cleanup:
+ virObjectUnlock(dmn);
+}
+
+
+void
+virNetDaemonQuit(virNetDaemonPtr dmn)
+{
+ virObjectLock(dmn);
+
+ VIR_DEBUG("Quit requested %p", dmn);
+ dmn->quit = true;
+
+ virObjectUnlock(dmn);
+}
+
+
+void
+virNetDaemonClose(virNetDaemonPtr dmn)
+{
+ size_t i;
+
+ if (!dmn)
+ return;
+
+ virObjectLock(dmn);
+
+ for (i = 0; i < dmn->nservers; i++)
+ virNetServerClose(dmn->servers[i]);
+
+ virObjectUnlock(dmn);
+}
diff --git a/src/rpc/virnetdaemon.h b/src/rpc/virnetdaemon.h
new file mode 100644
index 000000000000..9e176d65ca6a
--- /dev/null
+++ b/src/rpc/virnetdaemon.h
@@ -0,0 +1,82 @@
+/*
+ * virnetdaemon.h
+ *
+ * Copyright (C) 2015 Red Hat, Inc.
+ *
+ * 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@xxxxxxxxxx>
+ */
+
+#ifndef __VIR_NET_DAEMON_H__
+# define __VIR_NET_DAEMON_H__
+
+# include <signal.h>
+
+# ifdef WITH_GNUTLS
+# include "virnettlscontext.h"
+# endif
+# include "virobject.h"
+# include "virjson.h"
+# include "virnetserverprogram.h"
+# include "virnetserverclient.h"
+# include "virnetserverservice.h"
+# include "virnetserver.h"
+
+virNetDaemonPtr virNetDaemonNew(void);
+
+int virNetDaemonAddServer(virNetDaemonPtr dmn, virNetServerPtr);
+
+virNetServerPtr virNetDaemonAddServerPostExec(virNetDaemonPtr dmn,
+ virNetServerClientPrivNew clientPrivNew,
+ virNetServerClientPrivNewPostExecRestart clientPrivNewPostExecRestart,
+ virNetServerClientPrivPreExecRestart clientPrivPreExecRestart,
+ virFreeCallback clientPrivFree,
+ void *clientPrivOpaque);
+
+virNetDaemonPtr virNetDaemonNewPostExecRestart(virJSONValuePtr object);
+
+virJSONValuePtr virNetDaemonPreExecRestart(virNetDaemonPtr dmn);
+
+typedef int (*virNetDaemonAutoShutdownFunc)(virNetDaemonPtr dmn, void *opaque);
+
+bool virNetDaemonIsPrivileged(virNetDaemonPtr dmn);
+
+void virNetDaemonAutoShutdown(virNetDaemonPtr dmn,
+ unsigned int timeout);
+
+void virNetDaemonAddShutdownInhibition(virNetDaemonPtr dmn);
+void virNetDaemonRemoveShutdownInhibition(virNetDaemonPtr dmn);
+
+typedef void (*virNetDaemonSignalFunc)(virNetDaemonPtr dmn, siginfo_t *info, void *opaque);
+
+int virNetDaemonAddSignalHandler(virNetDaemonPtr dmn,
+ int signum,
+ virNetDaemonSignalFunc func,
+ void *opaque);
+
+void virNetDaemonUpdateServices(virNetDaemonPtr dmn,
+ bool enabled);
+
+void virNetDaemonRun(virNetDaemonPtr dmn);
+
+void virNetDaemonQuit(virNetDaemonPtr dmn);
+
+void virNetDaemonClose(virNetDaemonPtr dmn);
+
+virNetServerPtr virNetDaemonGetServer(virNetDaemonPtr dmn,
+ int subServerID);
+
+#endif /* __VIR_NET_DAEMON_H__ */
diff --git a/src/rpc/virnetserver.c b/src/rpc/virnetserver.c
index 2af878977a1b..60a9714f6096 100644
--- a/src/rpc/virnetserver.c
+++ b/src/rpc/virnetserver.c
@@ -1,7 +1,7 @@
/*
* virnetserver.c: generic network RPC server
*
- * Copyright (C) 2006-2012, 2014 Red Hat, Inc.
+ * Copyright (C) 2006-2015 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
@@ -23,40 +23,19 @@
#include <config.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-
#include "virnetserver.h"
#include "virlog.h"
#include "viralloc.h"
#include "virerror.h"
#include "virthread.h"
#include "virthreadpool.h"
-#include "virutil.h"
-#include "virfile.h"
#include "virnetservermdns.h"
-#include "virdbus.h"
#include "virstring.h"
-#include "virsystemd.h"
-
-#ifndef SA_SIGINFO
-# define SA_SIGINFO 0
-#endif
#define VIR_FROM_THIS VIR_FROM_RPC
VIR_LOG_INIT("rpc.netserver");
-typedef struct _virNetServerSignal virNetServerSignal;
-typedef virNetServerSignal *virNetServerSignalPtr;
-
-struct _virNetServerSignal {
- struct sigaction oldaction;
- int signum;
- virNetServerSignalFunc func;
- void *opaque;
-};
typedef struct _virNetServerJob virNetServerJob;
typedef virNetServerJob *virNetServerJobPtr;
@@ -72,14 +51,6 @@ struct _virNetServer {
virThreadPoolPtr workers;
- bool privileged;
-
- size_t nsignals;
- virNetServerSignalPtr *signals;
- int sigread;
- int sigwrite;
- int sigwatch;
-
char *mdnsGroupName;
virNetServerMDNSPtr mdns;
virNetServerMDNSGroupPtr mdnsGroup;
@@ -100,17 +71,10 @@ struct _virNetServer {
unsigned int keepaliveCount;
bool keepaliveRequired;
- bool quit;
-
#ifdef WITH_GNUTLS
virNetTLSContextPtr tls;
#endif
- unsigned int autoShutdownTimeout;
- size_t autoShutdownInhibitions;
- bool autoShutdownCallingInhibit;
- int autoShutdownInhibitFd;
-
virNetServerClientPrivNew clientPrivNew;
virNetServerClientPrivPreExecRestart clientPrivPreExecRestart;
virFreeCallback clientPrivFree;
@@ -356,7 +320,6 @@ virNetServerPtr virNetServerNew(size_t min_workers,
void *clientPrivOpaque)
{
virNetServerPtr srv;
- struct sigaction sig_action;
if (virNetServerInitialize() < 0)
return NULL;
@@ -376,13 +339,10 @@ virNetServerPtr virNetServerNew(size_t min_workers,
srv->keepaliveInterval = keepaliveInterval;
srv->keepaliveCount = keepaliveCount;
srv->keepaliveRequired = keepaliveRequired;
- srv->sigwrite = srv->sigread = -1;
srv->clientPrivNew = clientPrivNew;
srv->clientPrivPreExecRestart = clientPrivPreExecRestart;
srv->clientPrivFree = clientPrivFree;
srv->clientPrivOpaque = clientPrivOpaque;
- srv->privileged = geteuid() == 0;
- srv->autoShutdownInhibitFd = -1;
if (VIR_STRDUP(srv->mdnsGroupName, mdnsGroupName) < 0)
goto error;
@@ -394,15 +354,7 @@ virNetServerPtr virNetServerNew(size_t min_workers,
goto error;
}
- if (virEventRegisterDefaultImpl() < 0)
- goto error;
-
- memset(&sig_action, 0, sizeof(sig_action));
- sig_action.sa_handler = SIG_IGN;
- sigaction(SIGPIPE, &sig_action, NULL);
-
return srv;
-
error:
virObjectUnref(srv);
return NULL;
@@ -499,7 +451,7 @@ virNetServerPtr virNetServerNewPostExecRestart(virJSONValuePtr object,
goto error;
}
- n = virJSONValueArraySize(services);
+ n = virJSONValueArraySize(services);
if (n < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Malformed services data in JSON document"));
@@ -532,7 +484,7 @@ virNetServerPtr virNetServerNewPostExecRestart(virJSONValuePtr object,
goto error;
}
- n = virJSONValueArraySize(clients);
+ n = virJSONValueArraySize(clients);
if (n < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Malformed clients data in JSON document"));
@@ -679,286 +631,6 @@ virJSONValuePtr virNetServerPreExecRestart(virNetServerPtr srv)
}
-bool virNetServerIsPrivileged(virNetServerPtr srv)
-{
- bool priv;
- virObjectLock(srv);
- priv = srv->privileged;
- virObjectUnlock(srv);
- return priv;
-}
-
-
-void virNetServerAutoShutdown(virNetServerPtr srv,
- unsigned int timeout)
-{
- virObjectLock(srv);
-
- srv->autoShutdownTimeout = timeout;
-
- virObjectUnlock(srv);
-}
-
-
-#if defined(HAVE_DBUS) && defined(DBUS_TYPE_UNIX_FD)
-static void virNetServerGotInhibitReply(DBusPendingCall *pending,
- void *opaque)
-{
- virNetServerPtr srv = opaque;
- DBusMessage *reply;
- int fd;
-
- virObjectLock(srv);
- srv->autoShutdownCallingInhibit = false;
-
- VIR_DEBUG("srv=%p", srv);
-
- reply = dbus_pending_call_steal_reply(pending);
- if (reply == NULL)
- goto cleanup;
-
- if (dbus_message_get_args(reply, NULL,
- DBUS_TYPE_UNIX_FD, &fd,
- DBUS_TYPE_INVALID)) {
- if (srv->autoShutdownInhibitions) {
- srv->autoShutdownInhibitFd = fd;
- } else {
- /* We stopped the last VM since we made the inhibit call */
- VIR_FORCE_CLOSE(fd);
- }
- }
- dbus_message_unref(reply);
-
- cleanup:
- virObjectUnlock(srv);
-}
-
-
-/* As per: http://www.freedesktop.org/wiki/Software/systemd/inhibit */
-static void virNetServerCallInhibit(virNetServerPtr srv,
- const char *what,
- const char *who,
- const char *why,
- const char *mode)
-{
- DBusMessage *message;
- DBusPendingCall *pendingReply;
- DBusConnection *systemBus;
-
- VIR_DEBUG("srv=%p what=%s who=%s why=%s mode=%s",
- srv, NULLSTR(what), NULLSTR(who), NULLSTR(why), NULLSTR(mode));
-
- if (!(systemBus = virDBusGetSystemBus()))
- return;
-
- /* Only one outstanding call at a time */
- if (srv->autoShutdownCallingInhibit)
- return;
-
- message = dbus_message_new_method_call("org.freedesktop.login1",
- "/org/freedesktop/login1",
- "org.freedesktop.login1.Manager",
- "Inhibit");
- if (message == NULL)
- return;
-
- dbus_message_append_args(message,
- DBUS_TYPE_STRING, &what,
- DBUS_TYPE_STRING, &who,
- DBUS_TYPE_STRING, &why,
- DBUS_TYPE_STRING, &mode,
- DBUS_TYPE_INVALID);
-
- pendingReply = NULL;
- if (dbus_connection_send_with_reply(systemBus, message,
- &pendingReply,
- 25*1000)) {
- dbus_pending_call_set_notify(pendingReply,
- virNetServerGotInhibitReply,
- srv, NULL);
- srv->autoShutdownCallingInhibit = true;
- }
- dbus_message_unref(message);
-}
-#endif
-
-void virNetServerAddShutdownInhibition(virNetServerPtr srv)
-{
- virObjectLock(srv);
- srv->autoShutdownInhibitions++;
-
- VIR_DEBUG("srv=%p inhibitions=%zu", srv, srv->autoShutdownInhibitions);
-
-#if defined(HAVE_DBUS) && defined(DBUS_TYPE_UNIX_FD)
- if (srv->autoShutdownInhibitions == 1)
- virNetServerCallInhibit(srv,
- "shutdown",
- _("Libvirt"),
- _("Virtual machines need to be saved"),
- "delay");
-#endif
-
- virObjectUnlock(srv);
-}
-
-
-void virNetServerRemoveShutdownInhibition(virNetServerPtr srv)
-{
- virObjectLock(srv);
- srv->autoShutdownInhibitions--;
-
- VIR_DEBUG("srv=%p inhibitions=%zu", srv, srv->autoShutdownInhibitions);
-
- if (srv->autoShutdownInhibitions == 0)
- VIR_FORCE_CLOSE(srv->autoShutdownInhibitFd);
-
- virObjectUnlock(srv);
-}
-
-
-
-static sig_atomic_t sigErrors;
-static int sigLastErrno;
-static int sigWrite = -1;
-
-static void
-virNetServerSignalHandler(int sig, siginfo_t * siginfo,
- void* context ATTRIBUTE_UNUSED)
-{
- int origerrno;
- int r;
- siginfo_t tmp;
-
- if (SA_SIGINFO)
- tmp = *siginfo;
- else
- memset(&tmp, 0, sizeof(tmp));
-
- /* set the sig num in the struct */
- tmp.si_signo = sig;
-
- origerrno = errno;
- r = safewrite(sigWrite, &tmp, sizeof(tmp));
- if (r == -1) {
- sigErrors++;
- sigLastErrno = errno;
- }
- errno = origerrno;
-}
-
-static void
-virNetServerSignalEvent(int watch,
- int fd ATTRIBUTE_UNUSED,
- int events ATTRIBUTE_UNUSED,
- void *opaque)
-{
- virNetServerPtr srv = opaque;
- siginfo_t siginfo;
- size_t i;
-
- virObjectLock(srv);
-
- if (saferead(srv->sigread, &siginfo, sizeof(siginfo)) != sizeof(siginfo)) {
- virReportSystemError(errno, "%s",
- _("Failed to read from signal pipe"));
- virEventRemoveHandle(watch);
- srv->sigwatch = -1;
- goto cleanup;
- }
-
- for (i = 0; i < srv->nsignals; i++) {
- if (siginfo.si_signo == srv->signals[i]->signum) {
- virNetServerSignalFunc func = srv->signals[i]->func;
- void *funcopaque = srv->signals[i]->opaque;
- virObjectUnlock(srv);
- func(srv, &siginfo, funcopaque);
- return;
- }
- }
-
- virReportError(VIR_ERR_INTERNAL_ERROR,
- _("Unexpected signal received: %d"), siginfo.si_signo);
-
- cleanup:
- virObjectUnlock(srv);
-}
-
-static int virNetServerSignalSetup(virNetServerPtr srv)
-{
- int fds[2] = { -1, -1 };
-
- if (srv->sigwrite != -1)
- return 0;
-
- if (pipe2(fds, O_CLOEXEC|O_NONBLOCK) < 0) {
- virReportSystemError(errno, "%s",
- _("Unable to create signal pipe"));
- return -1;
- }
-
- if ((srv->sigwatch = virEventAddHandle(fds[0],
- VIR_EVENT_HANDLE_READABLE,
- virNetServerSignalEvent,
- srv, NULL)) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Failed to add signal handle watch"));
- goto error;
- }
-
- srv->sigread = fds[0];
- srv->sigwrite = fds[1];
- sigWrite = fds[1];
-
- return 0;
-
- error:
- VIR_FORCE_CLOSE(fds[0]);
- VIR_FORCE_CLOSE(fds[1]);
- return -1;
-}
-
-int virNetServerAddSignalHandler(virNetServerPtr srv,
- int signum,
- virNetServerSignalFunc func,
- void *opaque)
-{
- virNetServerSignalPtr sigdata = NULL;
- struct sigaction sig_action;
-
- virObjectLock(srv);
-
- if (virNetServerSignalSetup(srv) < 0)
- goto error;
-
- if (VIR_EXPAND_N(srv->signals, srv->nsignals, 1) < 0)
- goto error;
-
- if (VIR_ALLOC(sigdata) < 0)
- goto error;
-
- sigdata->signum = signum;
- sigdata->func = func;
- sigdata->opaque = opaque;
-
- memset(&sig_action, 0, sizeof(sig_action));
- sig_action.sa_sigaction = virNetServerSignalHandler;
- sig_action.sa_flags = SA_SIGINFO;
- sigemptyset(&sig_action.sa_mask);
-
- sigaction(signum, &sig_action, &sigdata->oldaction);
-
- srv->signals[srv->nsignals-1] = sigdata;
-
- virObjectUnlock(srv);
- return 0;
-
- error:
- VIR_FREE(sigdata);
- virObjectUnlock(srv);
- return -1;
-}
-
-
int virNetServerAddService(virNetServerPtr srv,
virNetServerServicePtr svc,
@@ -1023,22 +695,6 @@ int virNetServerSetTLSContext(virNetServerPtr srv,
#endif
-static void virNetServerAutoShutdownTimer(int timerid ATTRIBUTE_UNUSED,
- void *opaque)
-{
- virNetServerPtr srv = opaque;
-
- virObjectLock(srv);
-
- if (!srv->autoShutdownInhibitions) {
- VIR_DEBUG("Automatic shutdown triggered");
- srv->quit = true;
- }
-
- virObjectUnlock(srv);
-}
-
-
static void
virNetServerUpdateServicesLocked(virNetServerPtr srv,
bool enabled)
@@ -1087,127 +743,16 @@ virNetServerCheckLimits(virNetServerPtr srv)
}
}
-void virNetServerRun(virNetServerPtr srv)
-{
- int timerid = -1;
- bool timerActive = false;
- size_t i;
-
- virObjectLock(srv);
-
- if (srv->mdns &&
- virNetServerMDNSStart(srv->mdns) < 0)
- goto cleanup;
-
- srv->quit = false;
-
- if (srv->autoShutdownTimeout &&
- (timerid = virEventAddTimeout(-1,
- virNetServerAutoShutdownTimer,
- srv, NULL)) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Failed to register shutdown timeout"));
- goto cleanup;
- }
-
- /* We are accepting connections now. Notify systemd
- * so it can start dependent services. */
- virSystemdNotifyStartup();
-
- VIR_DEBUG("srv=%p quit=%d", srv, srv->quit);
- while (!srv->quit) {
- /* A shutdown timeout is specified, so check
- * if any drivers have active state, if not
- * shutdown after timeout seconds
- */
- if (srv->autoShutdownTimeout) {
- if (timerActive) {
- if (srv->clients) {
- VIR_DEBUG("Deactivating shutdown timer %d", timerid);
- virEventUpdateTimeout(timerid, -1);
- timerActive = false;
- }
- } else {
- if (!srv->clients) {
- VIR_DEBUG("Activating shutdown timer %d", timerid);
- virEventUpdateTimeout(timerid,
- srv->autoShutdownTimeout * 1000);
- timerActive = true;
- }
- }
- }
-
- virObjectUnlock(srv);
- if (virEventRunDefaultImpl() < 0) {
- virObjectLock(srv);
- VIR_DEBUG("Loop iteration error, exiting");
- break;
- }
- virObjectLock(srv);
-
- reprocess:
- for (i = 0; i < srv->nclients; i++) {
- /* Coverity 5.3.0 couldn't see that srv->clients is non-NULL
- * if srv->nclients is non-zero. */
- sa_assert(srv->clients);
- if (virNetServerClientWantClose(srv->clients[i]))
- virNetServerClientClose(srv->clients[i]);
- if (virNetServerClientIsClosed(srv->clients[i])) {
- virNetServerClientPtr client = srv->clients[i];
-
- VIR_DELETE_ELEMENT(srv->clients, i, srv->nclients);
-
- if (virNetServerClientNeedAuth(client))
- virNetServerTrackCompletedAuthLocked(srv);
-
- virNetServerCheckLimits(srv);
-
- virObjectUnlock(srv);
- virObjectUnref(client);
- virObjectLock(srv);
-
- goto reprocess;
- }
- }
- }
-
- cleanup:
- virObjectUnlock(srv);
-}
-
-
-void virNetServerQuit(virNetServerPtr srv)
-{
- virObjectLock(srv);
-
- VIR_DEBUG("Quit requested %p", srv);
- srv->quit = true;
-
- virObjectUnlock(srv);
-}
-
void virNetServerDispose(void *obj)
{
virNetServerPtr srv = obj;
size_t i;
- VIR_FORCE_CLOSE(srv->autoShutdownInhibitFd);
-
for (i = 0; i < srv->nservices; i++)
virNetServerServiceToggle(srv->services[i], false);
virThreadPoolFree(srv->workers);
- for (i = 0; i < srv->nsignals; i++) {
- sigaction(srv->signals[i]->signum, &srv->signals[i]->oldaction, NULL);
- VIR_FREE(srv->signals[i]);
- }
- VIR_FREE(srv->signals);
- VIR_FORCE_CLOSE(srv->sigread);
- VIR_FORCE_CLOSE(srv->sigwrite);
- if (srv->sigwatch > 0)
- virEventRemoveHandle(srv->sigwatch);
-
for (i = 0; i < srv->nservices; i++)
virObjectUnref(srv->services[i]);
VIR_FREE(srv->services);
@@ -1280,3 +825,62 @@ size_t virNetServerTrackCompletedAuth(virNetServerPtr srv)
virObjectUnlock(srv);
return ret;
}
+
+bool
+virNetServerHasClients(virNetServerPtr srv)
+{
+ bool ret;
+
+ virObjectLock(srv);
+ ret = !!srv->nclients;
+ virObjectUnlock(srv);
+
+ return ret;
+}
+
+void
+virNetServerProcessClients(virNetServerPtr srv)
+{
+ size_t i;
+
+ virObjectLock(srv);
+
+ reprocess:
+ for (i = 0; i < srv->nclients; i++) {
+ /* Coverity 5.3.0 couldn't see that srv->clients is non-NULL
+ * if srv->nclients is non-zero. */
+ sa_assert(srv->clients);
+ if (virNetServerClientWantClose(srv->clients[i]))
+ virNetServerClientClose(srv->clients[i]);
+ if (virNetServerClientIsClosed(srv->clients[i])) {
+ virNetServerClientPtr client = srv->clients[i];
+
+ VIR_DELETE_ELEMENT(srv->clients, i, srv->nclients);
+
+ if (virNetServerClientNeedAuth(client))
+ virNetServerTrackCompletedAuthLocked(srv);
+
+ virNetServerCheckLimits(srv);
+
+ virObjectUnlock(srv);
+ virObjectUnref(client);
+ virObjectLock(srv);
+
+ goto reprocess;
+ }
+ }
+
+ virObjectUnlock(srv);
+}
+
+int
+virNetServerStart(virNetServerPtr srv)
+{
+ /*
+ * Do whatever needs to be done before starting.
+ */
+ if (!srv->mdns)
+ return 0;
+
+ return virNetServerMDNSStart(srv->mdns);
+}
diff --git a/src/rpc/virnetserver.h b/src/rpc/virnetserver.h
index 4b452be5a1ad..5c28182ffd15 100644
--- a/src/rpc/virnetserver.h
+++ b/src/rpc/virnetserver.h
@@ -1,7 +1,7 @@
/*
* virnetserver.h: generic network RPC server
*
- * Copyright (C) 2006-2011 Red Hat, Inc.
+ * Copyright (C) 2006-2015 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
@@ -24,8 +24,6 @@
#ifndef __VIR_NET_SERVER_H__
# define __VIR_NET_SERVER_H__
-# include <signal.h>
-
# ifdef WITH_GNUTLS
# include "virnettlscontext.h"
# endif
@@ -35,6 +33,9 @@
# include "virobject.h"
# include "virjson.h"
+typedef struct _virNetServer virNetServer;
+typedef virNetServer *virNetServerPtr;
+
virNetServerPtr virNetServerNew(size_t min_workers,
size_t max_workers,
size_t priority_workers,
@@ -56,24 +57,9 @@ virNetServerPtr virNetServerNewPostExecRestart(virJSONValuePtr object,
virFreeCallback clientPrivFree,
void *clientPrivOpaque);
-virJSONValuePtr virNetServerPreExecRestart(virNetServerPtr srv);
-
-typedef int (*virNetServerAutoShutdownFunc)(virNetServerPtr srv, void *opaque);
-
-bool virNetServerIsPrivileged(virNetServerPtr srv);
-
-void virNetServerAutoShutdown(virNetServerPtr srv,
- unsigned int timeout);
-
-void virNetServerAddShutdownInhibition(virNetServerPtr srv);
-void virNetServerRemoveShutdownInhibition(virNetServerPtr srv);
-
-typedef void (*virNetServerSignalFunc)(virNetServerPtr srv, siginfo_t *info, void *opaque);
+void virNetServerClose(virNetServerPtr srv);
-int virNetServerAddSignalHandler(virNetServerPtr srv,
- int signum,
- virNetServerSignalFunc func,
- void *opaque);
+virJSONValuePtr virNetServerPreExecRestart(virNetServerPtr srv);
int virNetServerAddService(virNetServerPtr srv,
virNetServerServicePtr svc,
@@ -90,18 +76,18 @@ int virNetServerSetTLSContext(virNetServerPtr srv,
virNetTLSContextPtr tls);
# endif
-void virNetServerUpdateServices(virNetServerPtr srv,
- bool enabled);
-
-void virNetServerRun(virNetServerPtr srv);
-
-void virNetServerQuit(virNetServerPtr srv);
-
-void virNetServerClose(virNetServerPtr srv);
-
bool virNetServerKeepAliveRequired(virNetServerPtr srv);
size_t virNetServerTrackPendingAuth(virNetServerPtr srv);
size_t virNetServerTrackCompletedAuth(virNetServerPtr srv);
-#endif
+int virNetServerAddClient(virNetServerPtr srv,
+ virNetServerClientPtr client);
+bool virNetServerHasClients(virNetServerPtr srv);
+void virNetServerProcessClients(virNetServerPtr srv);
+
+void virNetServerUpdateServices(virNetServerPtr srv, bool enabled);
+
+int virNetServerStart(virNetServerPtr srv);
+
+#endif /* __VIR_NET_SERVER_H__ */
diff --git a/src/rpc/virnetserverprogram.h b/src/rpc/virnetserverprogram.h
index c1ae17ee5f22..0ccc372e8d7d 100644
--- a/src/rpc/virnetserverprogram.h
+++ b/src/rpc/virnetserverprogram.h
@@ -28,6 +28,9 @@
# include "virnetserverclient.h"
# include "virobject.h"
+typedef struct _virNetDaemon virNetDaemon;
+typedef virNetDaemon *virNetDaemonPtr;
+
typedef struct _virNetServer virNetServer;
typedef virNetServer *virNetServerPtr;
--
2.4.3
--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list