/*
* remote_daemon.c: daemon start of day, guest process & i/o management
*
* Copyright (C) 2006-2018 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* 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
* .
*/
#include
#include
#include
#include
#include
#include
#include "libvirt_internal.h"
#include "virerror.h"
#include "virfile.h"
#include "virlog.h"
#include "virpidfile.h"
#include "virprocess.h"
#define VIR_FROM_THIS VIR_FROM_QEMU
#include "remote_daemon.h"
#include "remote_daemon_config.h"
#include "admin/admin_server_dispatch.h"
#include "viruuid.h"
#include "remote_driver.h"
#include "viralloc.h"
#include "virconf.h"
#include "virnetlink.h"
#include "virnetdaemon.h"
#include "remote_daemon_dispatch.h"
#include "virhook.h"
#include "viraudit.h"
#include "virstring.h"
#include "locking/lock_manager.h"
#include "viraccessmanager.h"
#include "virutil.h"
#include "virgettext.h"
#include "util/virnetdevopenvswitch.h"
#include "virsystemd.h"
#include "virhostuptime.h"
#include "virdaemon.h"
#include "driver.h"
#include "configmake.h"
#include "virgdbus.h"
VIR_LOG_INIT("daemon." DAEMON_NAME);
#ifndef SOCK_PREFIX
# define SOCK_PREFIX DAEMON_NAME
#endif
#if WITH_SASL
virNetSASLContextPtr saslCtxt = NULL;
#endif
virNetServerProgramPtr remoteProgram = NULL;
virNetServerProgramPtr qemuProgram = NULL;
volatile bool driversInitialized = false;
static void daemonErrorHandler(void *opaque G_GNUC_UNUSED,
virErrorPtr err G_GNUC_UNUSED)
{
/* Don't do anything, since logging infrastructure already
* took care of reporting the error */
}
static int daemonErrorLogFilter(virErrorPtr err, int priority)
{
/* These error codes don't really reflect real errors. They
* are expected events that occur when an app tries to check
* whether a particular guest already exists. This filters
* them to a lower log level to prevent pollution of syslog
*/
switch (err->code) {
case VIR_ERR_NO_DOMAIN:
case VIR_ERR_NO_NETWORK:
case VIR_ERR_NO_STORAGE_POOL:
case VIR_ERR_NO_STORAGE_VOL:
case VIR_ERR_NO_NODE_DEVICE:
case VIR_ERR_NO_INTERFACE:
case VIR_ERR_NO_NWFILTER:
case VIR_ERR_NO_NWFILTER_BINDING:
case VIR_ERR_NO_SECRET:
case VIR_ERR_NO_DOMAIN_SNAPSHOT:
case VIR_ERR_OPERATION_INVALID:
case VIR_ERR_NO_DOMAIN_METADATA:
case VIR_ERR_NO_SERVER:
case VIR_ERR_NO_CLIENT:
case VIR_ERR_NO_HOSTNAME:
return VIR_LOG_DEBUG;
}
return priority;
}
static int daemonInitialize(void)
{
#ifndef LIBVIRTD
# ifdef MODULE_NAME
/* This a dedicated per-driver daemon build */
if (virDriverLoadModule(MODULE_NAME, MODULE_NAME "Register", true) < 0)
return -1;
# else
/* This is virtproxyd which merely proxies to the per-driver
* daemons for back compat, and also allows IP connectivity.
*/
# endif
#else
/* This is the legacy monolithic libvirtd built with all drivers
*
* Note that the order is important: the first ones have a higher
* priority when calling virStateInitialize. We must register the
* network, storage and nodedev drivers before any stateful domain
* driver, since their resources must be auto-started before any
* domains can be auto-started.
*/
# ifdef WITH_NETWORK
if (virDriverLoadModule("network", "networkRegister", false) < 0)
return -1;
# endif
# ifdef WITH_INTERFACE
if (virDriverLoadModule("interface", "interfaceRegister", false) < 0)
return -1;
# endif
# ifdef WITH_SECRETS
if (virDriverLoadModule("secret", "secretRegister", false) < 0)
return -1;
# endif
# ifdef WITH_STORAGE
if (virDriverLoadModule("storage", "storageRegister", false) < 0)
return -1;
# endif
# ifdef WITH_NODE_DEVICES
if (virDriverLoadModule("nodedev", "nodedevRegister", false) < 0)
return -1;
# endif
# ifdef WITH_NWFILTER
if (virDriverLoadModule("nwfilter", "nwfilterRegister", false) < 0)
return -1;
# endif
# ifdef WITH_LIBXL
if (virDriverLoadModule("libxl", "libxlRegister", false) < 0)
return -1;
# endif
# ifdef WITH_QEMU
if (virDriverLoadModule("qemu", "qemuRegister", false) < 0)
return -1;
# endif
# ifdef WITH_LXC
if (virDriverLoadModule("lxc", "lxcRegister", false) < 0)
return -1;
# endif
# ifdef WITH_VBOX
if (virDriverLoadModule("vbox", "vboxRegister", false) < 0)
return -1;
# endif
# ifdef WITH_BHYVE
if (virDriverLoadModule("bhyve", "bhyveRegister", false) < 0)
return -1;
# endif
# ifdef WITH_VZ
if (virDriverLoadModule("vz", "vzRegister", false) < 0)
return -1;
# endif
#endif
return 0;
}
static int ATTRIBUTE_NONNULL(3)
daemonSetupNetworking(virNetServerPtr srv,
virNetServerPtr srvAdm,
struct daemonConfig *config,
#ifdef WITH_IP
bool ipsock,
bool privileged,
#endif /* ! WITH_IP */
const char *sock_path,
const char *sock_path_ro,
const char *sock_path_adm)
{
gid_t unix_sock_gid = 0;
int unix_sock_ro_mask = 0;
int unix_sock_rw_mask = 0;
int unix_sock_adm_mask = 0;
g_autoptr(virSystemdActivation) act = NULL;
virSystemdActivationMap actmap[] = {
{ .name = DAEMON_NAME ".socket", .family = AF_UNIX, .path = sock_path },
{ .name = DAEMON_NAME "-ro.socket", .family = AF_UNIX, .path = sock_path_ro },
{ .name = DAEMON_NAME "-admin.socket", .family = AF_UNIX, .path = sock_path_adm },
#ifdef WITH_IP
{ .name = DAEMON_NAME "-tcp.socket", .family = AF_INET },
{ .name = DAEMON_NAME "-tls.socket", .family = AF_INET },
#endif /* ! WITH_IP */
};
#ifdef WITH_IP
if ((actmap[3].port = virSocketAddrResolveService(config->tcp_port)) < 0)
return -1;
if ((actmap[4].port = virSocketAddrResolveService(config->tls_port)) < 0)
return -1;
#endif /* ! WITH_IP */
if (virSystemdGetActivation(actmap, G_N_ELEMENTS(actmap), &act) < 0)
return -1;
#ifdef WITH_IP
# ifdef LIBVIRTD
if (act && ipsock) {
VIR_ERROR(_("--listen parameter not permitted with systemd activation "
"sockets, see 'man libvirtd' for further guidance"));
return -1;
}
# else /* ! LIBVIRTD */
/*
* "ipsock" traditionally reflected whether --listen is set.
* The listen_tcp & listen_tls params in libvirtd.conf were
* not honoured unless --listen was set.
*
* In virtproxyd we dropped --listen, and have listen_tcp and
* listen_tls in the config file both default to 0. The user
* can turn on listening simply by setting the libvirtd.conf
* file settings and doesn't have to worry about also adding
* --listen, which is saner.
*
* Hence, we initialized ipsock == 1 by default with virtproxyd.
* When using systemd activation though, we clear ipsock, so
* later code doesn't have any surprising behaviour differences
* for virtproxyd vs libvirtd.
*/
if (act)
ipsock = 0;
# endif /* ! LIBVIRTD */
#endif /* ! WITH_IP */
if (config->unix_sock_group) {
if (virGetGroupID(config->unix_sock_group, &unix_sock_gid) < 0)
return -1;
}
if (virStrToLong_i(config->unix_sock_ro_perms, NULL, 8, &unix_sock_ro_mask) != 0) {
VIR_ERROR(_("Failed to parse mode '%s'"), config->unix_sock_ro_perms);
return -1;
}
if (virStrToLong_i(config->unix_sock_admin_perms, NULL, 8, &unix_sock_adm_mask) != 0) {
VIR_ERROR(_("Failed to parse mode '%s'"), config->unix_sock_admin_perms);
return -1;
}
if (virStrToLong_i(config->unix_sock_rw_perms, NULL, 8, &unix_sock_rw_mask) != 0) {
VIR_ERROR(_("Failed to parse mode '%s'"), config->unix_sock_rw_perms);
return -1;
}
if (virNetServerAddServiceUNIX(srv,
act,
DAEMON_NAME ".socket",
sock_path,
unix_sock_rw_mask,
unix_sock_gid,
config->auth_unix_rw,
NULL,
false,
config->max_queued_clients,
config->max_client_requests) < 0)
return -1;
if (sock_path_ro &&
virNetServerAddServiceUNIX(srv,
act,
DAEMON_NAME "-ro.socket",
sock_path_ro,
unix_sock_ro_mask,
unix_sock_gid,
config->auth_unix_ro,
NULL,
true,
config->max_queued_clients,
config->max_client_requests) < 0)
return -1;
if (sock_path_adm &&
virNetServerAddServiceUNIX(srvAdm,
act,
DAEMON_NAME "-admin.socket",
sock_path_adm,
unix_sock_adm_mask,
unix_sock_gid,
REMOTE_AUTH_NONE,
NULL,
false,
config->admin_max_queued_clients,
config->admin_max_client_requests) < 0)
return -1;
#ifdef WITH_IP
if (((ipsock && config->listen_tcp) || act) &&
virNetServerAddServiceTCP(srv,
act,
DAEMON_NAME "-tcp.socket",
config->listen_addr,
config->tcp_port,
AF_UNSPEC,
config->auth_tcp,
NULL,
false,
config->max_queued_clients,
config->max_client_requests) < 0)
return -1;
if (((ipsock && config->listen_tls) || (act && virSystemdActivationHasName(act, DAEMON_NAME "-tls.socket")))) {
virNetTLSContextPtr ctxt = NULL;
if (config->ca_file ||
config->cert_file ||
config->key_file) {
if (!config->ca_file) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("No CA certificate path set to match server key/cert"));
return -1;
}
if (!config->cert_file) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("No server certificate path set to match server key"));
return -1;
}
if (!config->key_file) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("No server key path set to match server cert"));
return -1;
}
VIR_DEBUG("Using CA='%s' cert='%s' key='%s'",
config->ca_file, config->cert_file, config->key_file);
if (!(ctxt = virNetTLSContextNewServer(config->ca_file,
config->crl_file,
config->cert_file,
config->key_file,
(const char *const*)config->tls_allowed_dn_list,
config->tls_priority,
config->tls_no_sanity_certificate ? false : true,
config->tls_no_verify_certificate ? false : true)))
return -1;
} else {
if (!(ctxt = virNetTLSContextNewServerPath(NULL,
!privileged,
(const char *const*)config->tls_allowed_dn_list,
config->tls_priority,
config->tls_no_sanity_certificate ? false : true,
config->tls_no_verify_certificate ? false : true)))
return -1;
}
VIR_DEBUG("Registering TLS socket %s:%s",
config->listen_addr, config->tls_port);
if (virNetServerAddServiceTCP(srv,
act,
DAEMON_NAME "-tls.socket",
config->listen_addr,
config->tls_port,
AF_UNSPEC,
config->auth_tls,
ctxt,
false,
config->max_queued_clients,
config->max_client_requests) < 0) {
virObjectUnref(ctxt);
return -1;
}
virObjectUnref(ctxt);
}
#endif /* ! WITH_IP */
if (act &&
virSystemdActivationComplete(act) < 0)
return -1;
#if WITH_SASL
if (virNetServerNeedsAuth(srv, REMOTE_AUTH_SASL) &&
!(saslCtxt = virNetSASLContextNewServer(
(const char *const*)config->sasl_allowed_username_list)))
return -1;
#endif
return 0;
}
/*
* Set up the openvswitch timeout
*/
static void
daemonSetupNetDevOpenvswitch(struct daemonConfig *config)
{
virNetDevOpenvswitchSetTimeout(config->ovs_timeout);
}
static int
daemonSetupAccessManager(struct daemonConfig *config)
{
virAccessManagerPtr mgr;
const char *none[] = { "none", NULL };
const char **drv = (const char **)config->access_drivers;
if (!drv ||
!drv[0])
drv = none;
if (!(mgr = virAccessManagerNewStack(drv)))
return -1;
virAccessManagerSetDefault(mgr);
virObjectUnref(mgr);
return 0;
}
/* Display version information. */
static void
daemonVersion(const char *argv0)
{
printf("%s (%s) %s\n", argv0, PACKAGE_NAME, PACKAGE_VERSION);
}
static void daemonShutdownHandler(virNetDaemonPtr dmn,
siginfo_t *sig G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
virNetDaemonQuit(dmn);
}
static void daemonReloadHandlerThread(void *opaque G_GNUC_UNUSED)
{
VIR_INFO("Reloading configuration on SIGHUP");
virHookCall(VIR_HOOK_DRIVER_DAEMON, "-",
VIR_HOOK_DAEMON_OP_RELOAD, SIGHUP, "SIGHUP", NULL, NULL);
if (virStateReload() < 0)
VIR_WARN("Error while reloading drivers");
}
static void daemonReloadHandler(virNetDaemonPtr dmn G_GNUC_UNUSED,
siginfo_t *sig G_GNUC_UNUSED,
void *opaque G_GNUC_UNUSED)
{
virThread thr;
if (!driversInitialized) {
VIR_WARN("Drivers are not initialized, reload ignored");
return;
}
if (virThreadCreateFull(&thr, false, daemonReloadHandlerThread,
"daemon-reload", false, NULL) < 0) {
/*
* Not much we can do on error here except log it.
*/
VIR_ERROR(_("Failed to create thread to handle daemon restart"));
}
}
static int daemonSetupSignals(virNetDaemonPtr dmn)
{
if (virNetDaemonAddSignalHandler(dmn, SIGINT, daemonShutdownHandler, NULL) < 0)
return -1;
if (virNetDaemonAddSignalHandler(dmn, SIGQUIT, daemonShutdownHandler, NULL) < 0)
return -1;
if (virNetDaemonAddSignalHandler(dmn, SIGTERM, daemonShutdownHandler, NULL) < 0)
return -1;
if (virNetDaemonAddSignalHandler(dmn, SIGHUP, daemonReloadHandler, NULL) < 0)
return -1;
return 0;
}
static void daemonInhibitCallback(bool inhibit, void *opaque)
{
virNetDaemonPtr dmn = opaque;
if (inhibit)
virNetDaemonAddShutdownInhibition(dmn);
else
virNetDaemonRemoveShutdownInhibition(dmn);
}
static GDBusConnection *sessionBus;
static GDBusConnection *systemBus;
static void daemonStopWorker(void *opaque)
{
virNetDaemonPtr dmn = opaque;
VIR_DEBUG("Begin stop dmn=%p", dmn);
ignore_value(virStateStop());
VIR_DEBUG("Completed stop dmn=%p", dmn);
/* Exit daemon cleanly */
virNetDaemonQuit(dmn);
}
/* We do this in a thread to not block the main loop */
static void daemonStop(virNetDaemonPtr dmn)
{
virThreadPtr thr;
virObjectRef(dmn);
thr = g_new0(virThread, 1);
if (virThreadCreateFull(thr, true,
daemonStopWorker,
"daemon-stop", false, dmn) < 0) {
virObjectUnref(dmn);
g_free(thr);
return;
}
virNetDaemonSetStateStopWorkerThread(dmn, &thr);
}
static GDBusMessage *
handleSessionMessageFunc(GDBusConnection *connection G_GNUC_UNUSED,
GDBusMessage *message,
gboolean incoming G_GNUC_UNUSED,
gpointer opaque)
{
virNetDaemonPtr dmn = opaque;
VIR_DEBUG("dmn=%p", dmn);
if (virGDBusMessageIsSignal(message,
"org.freedesktop.DBus.Local",
"Disconnected"))
daemonStop(dmn);
return message;
}
static void
handleSystemMessageFunc(GDBusConnection *connection G_GNUC_UNUSED,
const char *senderName G_GNUC_UNUSED,
const char *objectPath G_GNUC_UNUSED,
const char *interfaceName G_GNUC_UNUSED,
const char *signalName G_GNUC_UNUSED,
GVariant *parameters G_GNUC_UNUSED,
gpointer opaque)
{
virNetDaemonPtr dmn = opaque;
VIR_DEBUG("dmn=%p", dmn);
daemonStop(dmn);
}
static void daemonRunStateInit(void *opaque)
{
virNetDaemonPtr dmn = opaque;
g_autoptr(virIdentity) sysident = virIdentityGetSystem();
#ifdef MODULE_NAME
bool mandatory = true;
#else /* ! MODULE_NAME */
bool mandatory = false;
#endif /* ! MODULE_NAME */
virIdentitySetCurrent(sysident);
/* Since driver initialization can take time inhibit daemon shutdown until
we're done so clients get a chance to connect */
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(virNetDaemonIsPrivileged(dmn),
mandatory,
NULL,
daemonInhibitCallback,
dmn) < 0) {
VIR_ERROR(_("Driver state initialization failed"));
/* Ensure the main event loop quits */
kill(getpid(), SIGTERM);
goto cleanup;
}
driversInitialized = true;
/* Tie the non-privileged daemons to the session/shutdown lifecycle */
if (!virNetDaemonIsPrivileged(dmn)) {
sessionBus = virGDBusGetSessionBus();
if (sessionBus != NULL)
g_dbus_connection_add_filter(sessionBus,
handleSessionMessageFunc, dmn, NULL);
systemBus = virGDBusGetSystemBus();
if (systemBus != NULL)
g_dbus_connection_signal_subscribe(systemBus,
"org.freedesktop.login1",
"org.freedesktop.login1.Manager",
"PrepareForShutdown",
NULL,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
handleSystemMessageFunc,
dmn,
NULL);
}
/* Only now accept clients from network */
virNetDaemonUpdateServices(dmn, true);
cleanup:
daemonInhibitCallback(false, dmn);
virObjectUnref(dmn);
virIdentitySetCurrent(NULL);
}
static int daemonStateInit(virNetDaemonPtr dmn)
{
virThread thr;
virObjectRef(dmn);
if (virThreadCreateFull(&thr, false, daemonRunStateInit,
"daemon-init", false, dmn) < 0) {
virObjectUnref(dmn);
return -1;
}
return 0;
}
static int
daemonSetupHostUUID(const struct daemonConfig *config)
{
static const char *machine_id = "/etc/machine-id";
char buf[VIR_UUID_STRING_BUFLEN];
const char *uuid;
if (config->host_uuid) {
uuid = config->host_uuid;
} else if (!config->host_uuid_source ||
STREQ(config->host_uuid_source, "smbios")) {
/* smbios UUID is fetched on demand in virGetHostUUID */
return 0;
} else if (STREQ(config->host_uuid_source, "machine-id")) {
if (virFileReadBufQuiet(machine_id, buf, sizeof(buf)) < 0) {
VIR_ERROR(_("Can't read %s"), machine_id);
return -1;
}
uuid = buf;
} else {
VIR_ERROR(_("invalid UUID source: %s"), config->host_uuid_source);
return -1;
}
if (virSetHostUUIDStr(uuid)) {
VIR_ERROR(_("invalid host UUID: %s"), uuid);
return -1;
}
return 0;
}
typedef struct {
const char *opts;
const char *help;
} virOptionHelp;
/* Print command-line usage. */
static void
daemonUsage(const char *argv0, bool privileged)
{
size_t i;
virOptionHelp opthelp[] = {
{ "-h | --help", N_("Display program help") },
{ "-v | --verbose", N_("Verbose messages") },
{ "-d | --daemon", N_("Run as a daemon & write PID file") },
#if defined(WITH_IP) && defined(LIBVIRTD)
{ "-l | --listen", N_("Listen for TCP/IP connections") },
#endif /* !(WITH_IP && LIBVIRTD) */
{ "-t | --timeout ", N_("Exit after timeout period") },
{ "-f | --config ", N_("Configuration file") },
{ "-V | --version", N_("Display version information") },
{ "-p | --pid-file ", N_("Change name of PID file") },
};
fprintf(stderr, "\n");
fprintf(stderr, "%s\n", _("Usage:"));
fprintf(stderr, " %s [%s]\n", argv0, _("options"));
fprintf(stderr, "\n");
fprintf(stderr, "%s\n", _("Options:"));
for (i = 0; i < G_N_ELEMENTS(opthelp); i++)
fprintf(stderr, " %-22s %s\n", opthelp[i].opts,
_(opthelp[i].help));
fprintf(stderr, "\n");
fprintf(stderr, "%s\n", _("libvirt management daemon:"));
fprintf(stderr, "\n");
fprintf(stderr, " %s\n", _("Default paths:"));
fprintf(stderr, "\n");
fprintf(stderr, " %s\n", _("Configuration file (unless overridden by -f):"));
fprintf(stderr, " %s/libvirt/%s.conf\n",
privileged ? SYSCONFDIR : "$XDG_CONFIG_HOME", DAEMON_NAME);
fprintf(stderr, "\n");
fprintf(stderr, " %s\n", _("Sockets:"));
fprintf(stderr, " %s/libvirt/%s-sock\n",
privileged ? RUNSTATEDIR : "$XDG_RUNTIME_DIR",
SOCK_PREFIX);
if (privileged)
fprintf(stderr, " %s/libvirt/%s-sock-ro\n",
RUNSTATEDIR, SOCK_PREFIX);
fprintf(stderr, "\n");
#ifdef WITH_IP
fprintf(stderr, " %s\n", _("TLS:"));
fprintf(stderr, " %s %s\n",
_("CA certificate:"),
privileged ? LIBVIRT_CACERT : "$HOME/.pki/libvirt/cacert.pem");
fprintf(stderr, " %s %s\n",
_("Server certificate:"),
privileged ? LIBVIRT_SERVERCERT : "$HOME/.pki/libvirt/servercert.pem");
fprintf(stderr, " %s %s\n",
_("Server private key:"),
privileged ? LIBVIRT_SERVERKEY : "$HOME/.pki/libvirt/serverkey.pem");
fprintf(stderr, "\n");
#endif /* ! WITH_IP */
fprintf(stderr, " %s\n",
_("PID file (unless overridden by -p):"));
fprintf(stderr, " %s/%s.pid\n",
privileged ? RUNSTATEDIR : "$XDG_RUNTIME_DIR/libvirt",
DAEMON_NAME);
fprintf(stderr, "\n");
}
int main(int argc, char **argv) {
virNetDaemonPtr dmn = NULL;
virNetServerPtr srv = NULL;
virNetServerPtr srvAdm = NULL;
virNetServerProgramPtr adminProgram = NULL;
virNetServerProgramPtr lxcProgram = NULL;
char *remote_config_file = NULL;
int statuswrite = -1;
int ret = 1;
int pid_file_fd = -1;
char *pid_file = NULL;
char *sock_file = NULL;
char *sock_file_ro = NULL;
char *sock_file_adm = NULL;
int timeout = 0; /* -t: Shutdown timeout */
int verbose = 0;
int godaemon = 0;
#ifdef WITH_IP
# ifdef LIBVIRTD
int ipsock = 0;
# else /* ! LIBVIRTD */
int ipsock = 1; /* listen_tcp/listen_tls default to 0 */
# endif /* ! LIBVIRTD */
#endif /* ! WITH_IP */
struct daemonConfig *config;
bool privileged = geteuid() == 0;
bool implicit_conf = false;
char *run_dir = NULL;
mode_t old_umask;
struct option opts[] = {
{ "verbose", no_argument, &verbose, 'v'},
{ "daemon", no_argument, &godaemon, 'd'},
#if defined(WITH_IP) && defined(LIBVIRTD)
{ "listen", no_argument, &ipsock, 'l'},
#endif /* !(WITH_IP && LIBVIRTD) */
{ "config", required_argument, NULL, 'f'},
{ "timeout", required_argument, NULL, 't'},
{ "pid-file", required_argument, NULL, 'p'},
{ "version", no_argument, NULL, 'V' },
{ "help", no_argument, NULL, 'h' },
{0, 0, 0, 0}
};
if (virGettextInitialize() < 0 ||
virInitialize() < 0) {
fprintf(stderr, _("%s: initialization failed\n"), argv[0]);
exit(EXIT_FAILURE);
}
virUpdateSelfLastChanged(argv[0]);
virFileActivateDirOverrideForProg(argv[0]);
while (1) {
int optidx = 0;
int c;
char *tmp;
#if defined(WITH_IP) && defined(LIBVIRTD)
const char *optstr = "ldf:p:t:vVh";
#else /* !(WITH_IP && LIBVIRTD) */
const char *optstr = "df:p:t:vVh";
#endif /* !(WITH_IP && LIBVIRTD) */
c = getopt_long(argc, argv, optstr, opts, &optidx);
if (c == -1)
break;
switch (c) {
case 0:
/* Got one of the flags */
break;
case 'v':
verbose = 1;
break;
case 'd':
godaemon = 1;
break;
#if defined(WITH_IP) && defined(LIBVIRTD)
case 'l':
ipsock = 1;
break;
#endif /* !(WITH_IP && LIBVIRTD) */
case 't':
if (virStrToLong_i(optarg, &tmp, 10, &timeout) != 0
|| timeout < 0
/* Ensure that we can multiply by 1000 without overflowing. */
|| timeout > INT_MAX / 1000) {
VIR_ERROR(_("Invalid value for timeout"));
exit(EXIT_FAILURE);
}
break;
case 'p':
VIR_FREE(pid_file);
pid_file = g_strdup(optarg);
break;
case 'f':
VIR_FREE(remote_config_file);
remote_config_file = g_strdup(optarg);
break;
case 'V':
daemonVersion(argv[0]);
exit(EXIT_SUCCESS);
case 'h':
daemonUsage(argv[0], privileged);
exit(EXIT_SUCCESS);
case '?':
default:
daemonUsage(argv[0], privileged);
exit(EXIT_FAILURE);
}
}
if (optind != argc) {
fprintf(stderr, "%s: unexpected, non-option, command line arguments\n",
argv[0]);
exit(EXIT_FAILURE);
}
if (!(config = daemonConfigNew(privileged))) {
VIR_ERROR(_("Can't create initial configuration"));
exit(EXIT_FAILURE);
}
/* No explicit config, so try and find a default one */
if (remote_config_file == NULL) {
implicit_conf = true;
if (daemonConfigFilePath(privileged,
&remote_config_file) < 0) {
VIR_ERROR(_("Can't determine config path"));
exit(EXIT_FAILURE);
}
}
/* Read the config file if it exists */
if (remote_config_file &&
daemonConfigLoadFile(config, remote_config_file, implicit_conf) < 0) {
VIR_ERROR(_("Can't load config file: %s: %s"),
virGetLastErrorMessage(), remote_config_file);
exit(EXIT_FAILURE);
}
if (daemonSetupHostUUID(config) < 0) {
VIR_ERROR(_("Can't setup host uuid"));
exit(EXIT_FAILURE);
}
virDaemonSetupLogging(DAEMON_NAME,
config->log_level,
config->log_filters,
config->log_outputs,
privileged,
verbose,
godaemon);
/* Let's try to initialize global variable that holds the host's boot time. */
if (virHostBootTimeInit() < 0) {
/* This is acceptable failure. Maybe we won't need the boot time
* anyway, and if we do, then virHostGetBootTime() returns an
* appropriate error. */
VIR_DEBUG("Ignoring failed boot time init");
}
daemonSetupNetDevOpenvswitch(config);
if (daemonSetupAccessManager(config) < 0) {
VIR_ERROR(_("Can't initialize access manager"));
exit(EXIT_FAILURE);
}
if (!pid_file &&
virPidFileConstructPath(privileged,
RUNSTATEDIR,
DAEMON_NAME,
&pid_file) < 0) {
VIR_ERROR(_("Can't determine pid file path."));
exit(EXIT_FAILURE);
}
VIR_DEBUG("Decided on pid file path '%s'", NULLSTR(pid_file));
if (virDaemonUnixSocketPaths(SOCK_PREFIX,
privileged,
config->unix_sock_dir,
&sock_file,
&sock_file_ro,
&sock_file_adm) < 0) {
VIR_ERROR(_("Can't determine socket paths"));
exit(EXIT_FAILURE);
}
VIR_DEBUG("Decided on socket paths '%s', '%s' and '%s'",
sock_file,
NULLSTR(sock_file_ro),
NULLSTR(sock_file_adm));
if (godaemon) {
if (chdir("/") < 0) {
VIR_ERROR(_("cannot change to root directory: %s"),
g_strerror(errno));
goto cleanup;
}
if ((statuswrite = virDaemonForkIntoBackground(argv[0])) < 0) {
VIR_ERROR(_("Failed to fork as daemon: %s"),
g_strerror(errno));
goto cleanup;
}
}
/* Try to claim the pidfile, exiting if we can't */
if ((pid_file_fd = virPidFileAcquirePath(pid_file, false, getpid())) < 0) {
ret = VIR_DAEMON_ERR_PIDFILE;
goto cleanup;
}
/* Ensure the rundir exists (on tmpfs on some systems) */
if (privileged) {
run_dir = g_strdup(RUNSTATEDIR "/libvirt");
} else {
run_dir = virGetUserRuntimeDirectory();
}
if (privileged)
old_umask = umask(022);
else
old_umask = umask(077);
VIR_DEBUG("Ensuring run dir '%s' exists", run_dir);
if (virFileMakePath(run_dir) < 0) {
VIR_ERROR(_("unable to create rundir %s: %s"), run_dir,
g_strerror(errno));
ret = VIR_DAEMON_ERR_RUNDIR;
goto cleanup;
}
umask(old_umask);
if (virNetlinkStartup() < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (!(dmn = virNetDaemonNew())) {
ret = VIR_DAEMON_ERR_DRIVER;
goto cleanup;
}
if (!(srv = virNetServerNew(DAEMON_NAME, 1,
config->min_workers,
config->max_workers,
config->prio_workers,
config->max_clients,
config->max_anonymous_clients,
config->keepalive_interval,
config->keepalive_count,
remoteClientNew,
NULL,
remoteClientFree,
NULL))) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (virNetDaemonAddServer(dmn, srv) < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (daemonInitialize() < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
remoteProcs[REMOTE_PROC_AUTH_LIST].needAuth = false;
remoteProcs[REMOTE_PROC_AUTH_SASL_INIT].needAuth = false;
remoteProcs[REMOTE_PROC_AUTH_SASL_STEP].needAuth = false;
remoteProcs[REMOTE_PROC_AUTH_SASL_START].needAuth = false;
remoteProcs[REMOTE_PROC_AUTH_POLKIT].needAuth = false;
if (!(remoteProgram = virNetServerProgramNew(REMOTE_PROGRAM,
REMOTE_PROTOCOL_VERSION,
remoteProcs,
remoteNProcs))) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (virNetServerAddProgram(srv, remoteProgram) < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (!(lxcProgram = virNetServerProgramNew(LXC_PROGRAM,
LXC_PROTOCOL_VERSION,
lxcProcs,
lxcNProcs))) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (virNetServerAddProgram(srv, lxcProgram) < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (!(qemuProgram = virNetServerProgramNew(QEMU_PROGRAM,
QEMU_PROTOCOL_VERSION,
qemuProcs,
qemuNProcs))) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (virNetServerAddProgram(srv, qemuProgram) < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (!(srvAdm = virNetServerNew("admin", 1,
config->admin_min_workers,
config->admin_max_workers,
0,
config->admin_max_clients,
0,
config->admin_keepalive_interval,
config->admin_keepalive_count,
remoteAdmClientNew,
NULL,
remoteAdmClientFree,
dmn))) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (virNetDaemonAddServer(dmn, srvAdm) < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (!(adminProgram = virNetServerProgramNew(ADMIN_PROGRAM,
ADMIN_PROTOCOL_VERSION,
adminProcs,
adminNProcs))) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (virNetServerAddProgram(srvAdm, adminProgram) < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
if (timeout > 0) {
VIR_DEBUG("Registering shutdown timeout %d", timeout);
virNetDaemonAutoShutdown(dmn, timeout);
}
if ((daemonSetupSignals(dmn)) < 0) {
ret = VIR_DAEMON_ERR_SIGNAL;
goto cleanup;
}
if (config->audit_level) {
VIR_DEBUG("Attempting to configure auditing subsystem");
if (virAuditOpen(config->audit_level) < 0) {
if (config->audit_level > 1) {
ret = VIR_DAEMON_ERR_AUDIT;
goto cleanup;
}
VIR_DEBUG("Proceeding without auditing");
}
}
virAuditLog(config->audit_logging > 0);
/* setup the hooks if any */
if (virHookInitialize() < 0) {
ret = VIR_DAEMON_ERR_HOOKS;
goto cleanup;
}
/* Disable error func, now logging is setup */
virSetErrorFunc(NULL, daemonErrorHandler);
virSetErrorLogPriorityFunc(daemonErrorLogFilter);
/*
* Call the daemon startup hook
* TODO: should we abort the daemon startup if the script returned
* an error ?
*/
virHookCall(VIR_HOOK_DRIVER_DAEMON, "-", VIR_HOOK_DAEMON_OP_START,
0, "start", NULL, NULL);
if (daemonSetupNetworking(srv, srvAdm,
config,
#ifdef WITH_IP
ipsock,
privileged,
#endif /* !WITH_IP */
sock_file,
sock_file_ro,
sock_file_adm) < 0) {
ret = VIR_DAEMON_ERR_NETWORK;
goto cleanup;
}
/* Tell parent of daemon that basic initialization is complete
* In particular we're ready to accept net connections & have
* written the pidfile
*/
if (statuswrite != -1) {
char status = 0;
ignore_value(safewrite(statuswrite, &status, 1));
VIR_FORCE_CLOSE(statuswrite);
}
/* Initialize drivers & then start accepting new clients from network */
if (daemonStateInit(dmn) < 0) {
ret = VIR_DAEMON_ERR_INIT;
goto cleanup;
}
#if defined(__linux__) && defined(NETLINK_ROUTE)
/* Register the netlink event service for NETLINK_ROUTE */
if (virNetlinkEventServiceStart(NETLINK_ROUTE, 0) < 0) {
ret = VIR_DAEMON_ERR_NETWORK;
goto cleanup;
}
#endif
#if defined(__linux__) && defined(NETLINK_KOBJECT_UEVENT)
/* Register the netlink event service for NETLINK_KOBJECT_UEVENT */
if (virNetlinkEventServiceStart(NETLINK_KOBJECT_UEVENT, 1) < 0) {
ret = VIR_DAEMON_ERR_NETWORK;
goto cleanup;
}
#endif
/* Run event loop. */
virNetDaemonSetShutdownCallbacks(dmn,
virStateShutdownPrepare,
virStateShutdownWait);
virNetDaemonRun(dmn);
ret = 0;
virHookCall(VIR_HOOK_DRIVER_DAEMON, "-", VIR_HOOK_DAEMON_OP_SHUTDOWN,
0, "shutdown", NULL, NULL);
cleanup:
virNetlinkEventServiceStopAll();
if (driversInitialized) {
/* NB: Possible issue with timing window between driversInitialized
* setting if virNetlinkEventServerStart fails */
driversInitialized = false;
virStateCleanup();
}
virObjectUnref(adminProgram);
virObjectUnref(srvAdm);
virObjectUnref(qemuProgram);
virObjectUnref(lxcProgram);
virObjectUnref(remoteProgram);
virObjectUnref(srv);
virObjectUnref(dmn);
virNetlinkShutdown();
if (pid_file_fd != -1)
virPidFileReleasePath(pid_file, pid_file_fd);
VIR_FREE(run_dir);
if (statuswrite != -1) {
if (ret != 0) {
/* Tell parent of daemon what failed */
char status = ret;
ignore_value(safewrite(statuswrite, &status, 1));
}
VIR_FORCE_CLOSE(statuswrite);
}
VIR_FREE(sock_file);
VIR_FREE(sock_file_ro);
VIR_FREE(sock_file_adm);
VIR_FREE(pid_file);
VIR_FREE(remote_config_file);
daemonConfigFree(config);
return ret;
}