X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=b8e933088b28f5c7eb3aed788287af48ab0df365;hp=730be857f5e564fdfea8938dbfc134d1f3c679be;hb=f3e72665eb06410c6f7e49e030db92349fbbddbf;hpb=5314cebf5fe766bdca6c779e785b8dfaa3808142

diff --git a/discover/device-handler.c b/discover/device-handler.c
index 730be85..b8e9330 100644
--- a/discover/device-handler.c
+++ b/discover/device-handler.c
@@ -1,4 +1,5 @@
 #include <assert.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <unistd.h>
@@ -18,6 +19,7 @@
 #include <process/process.h>
 #include <url/url.h>
 #include <i18n/i18n.h>
+#include <pb-config/pb-config.h>
 
 #include <sys/sysmacros.h>
 #include <sys/types.h>
@@ -41,12 +43,15 @@
 #include "ipmi.h"
 
 enum default_priority {
-	DEFAULT_PRIORITY_REMOTE		= 1,
-	DEFAULT_PRIORITY_LOCAL_FIRST	= 2,
+	DEFAULT_PRIORITY_TEMP_USER	= 1,
+	DEFAULT_PRIORITY_REMOTE		= 2,
+	DEFAULT_PRIORITY_LOCAL_FIRST	= 3,
 	DEFAULT_PRIORITY_LOCAL_LAST	= 0xfe,
 	DEFAULT_PRIORITY_DISABLED	= 0xff,
 };
 
+static int default_rescan_timeout = 5 * 60; /* seconds */
+
 struct progress_info {
 	unsigned int			percentage;
 	unsigned long			size;		/* size in bytes */
@@ -73,6 +78,7 @@ struct device_handler {
 	struct waiter		*timeout_waiter;
 	bool			autoboot_enabled;
 	unsigned int		sec_to_boot;
+	struct autoboot_option	*temp_autoboot;
 
 	struct discover_boot_option *default_boot_option;
 	int			default_boot_option_priority;
@@ -84,6 +90,10 @@ struct device_handler {
 
 	struct list		progress;
 	unsigned int		n_progress;
+
+	struct plugin_option	**plugins;
+	unsigned int		n_plugins;
+	bool			plugin_installing;
 };
 
 static int mount_device(struct discover_device *dev);
@@ -126,6 +136,28 @@ const struct discover_device *device_handler_get_device(
 	return handler->devices[index];
 }
 
+/**
+ * device_handler_get_plugin_count - Get the count of current handler plugins.
+ */
+int device_handler_get_plugin_count(const struct device_handler *handler)
+{
+	return handler->n_plugins;
+}
+
+/**
+ * discover_handler_get_plugin - Get a handler plugin by index.
+ */
+const struct plugin_option *device_handler_get_plugin(
+	const struct device_handler *handler, unsigned int index)
+{
+	if (index >= handler->n_plugins) {
+		assert(0 && "bad index");
+		return NULL;
+	}
+
+	return handler->plugins[index];
+}
+
 struct network *device_handler_get_network(
 		const struct device_handler *handler)
 {
@@ -312,6 +344,22 @@ const char *discover_device_get_param(struct discover_device *device,
 	return NULL;
 }
 
+static void set_env_variables(const struct config *config)
+{
+	if (config->http_proxy)
+		setenv("http_proxy", config->http_proxy, 1);
+	else
+		unsetenv("http_proxy");
+
+	if (config->https_proxy)
+		setenv("https_proxy", config->https_proxy, 1);
+	else
+		unsetenv("https_proxy");
+
+	/* Reduce noise in the log from LVM listing open file descriptors */
+	setenv("LVM_SUPPRESS_FD_WARNINGS", "1", 1);
+}
+
 struct device_handler *device_handler_init(struct discover_server *server,
 		struct waitset *waitset, int dry_run)
 {
@@ -336,6 +384,8 @@ struct device_handler *device_handler_init(struct discover_server *server,
 	if (config_get()->safe_mode)
 		return handler;
 
+	set_env_variables(config_get());
+
 	rc = device_handler_init_sources(handler);
 	if (rc) {
 		talloc_free(handler);
@@ -349,6 +399,7 @@ void device_handler_reinit(struct device_handler *handler)
 {
 	struct discover_boot_option *opt, *tmp;
 	struct ramdisk_device *ramdisk;
+	struct config *config;
 	unsigned int i;
 
 	device_handler_cancel_default(handler);
@@ -371,10 +422,13 @@ void device_handler_reinit(struct device_handler *handler)
 
 	/* drop all devices */
 	for (i = 0; i < handler->n_devices; i++) {
+		struct discover_device *device = handler->devices[i];
 		discover_server_notify_device_remove(handler->server,
-				handler->devices[i]->device);
-		ramdisk = handler->devices[i]->ramdisk;
-		talloc_free(handler->devices[i]);
+				device->device);
+		ramdisk = device->ramdisk;
+		if (device->requery_waiter)
+			waiter_remove(device->requery_waiter);
+		talloc_free(device);
 		talloc_free(ramdisk);
 	}
 
@@ -385,6 +439,28 @@ void device_handler_reinit(struct device_handler *handler)
 	handler->ramdisks = NULL;
 	handler->n_ramdisks = 0;
 
+	/* drop any known plugins */
+	for (i = 0; i < handler->n_plugins; i++)
+		talloc_free(handler->plugins[i]);
+	talloc_free(handler->plugins);
+	handler->plugins = NULL;
+	handler->n_plugins = 0;
+
+	discover_server_notify_plugins_remove(handler->server);
+
+	set_env_variables(config_get());
+
+	/* If the safe mode warning was active disable it now */
+	if (config_get()->safe_mode) {
+		config = config_copy(handler, config_get());
+		config->safe_mode = false;
+		config_set(config);
+		discover_server_notify_config(handler->server, config);
+	}
+
+	/* Force rediscovery on SCSI devices */
+	process_run_simple(handler, pb_system_apps.scsi_rescan, NULL);
+
 	device_handler_reinit_sources(handler);
 }
 
@@ -394,6 +470,9 @@ void device_handler_remove(struct device_handler *handler,
 	struct discover_boot_option *opt, *tmp;
 	unsigned int i;
 
+	if (device->requery_waiter)
+		waiter_remove(device->requery_waiter);
+
 	list_for_each_entry_safe(&device->boot_options, opt, tmp, list) {
 		if (opt == handler->default_boot_option) {
 			pb_log("Default option %s cancelled since device removed",
@@ -588,7 +667,7 @@ void device_handler_status_download(struct device_handler *handler,
 			unit++;
 		}
 		update = talloc_asprintf(handler,
-				_("%u %s downloading: %.0f%% - %lu%cB"),
+				_("%u %s downloading: %.0f%% - %" PRIu64 "%cB"),
 				handler->n_progress,
 				ngettext("item", "items", handler->n_progress),
 				(current / total) * 100, current_converted,
@@ -603,6 +682,21 @@ void device_handler_status_download(struct device_handler *handler,
 	}
 }
 
+static void device_handler_plugin_scan_device(struct device_handler *handler,
+		struct discover_device *dev)
+{
+	int rc;
+
+	pb_debug("Scanning %s for plugin files\n", dev->device->id);
+
+	rc = process_run_simple(handler, pb_system_apps.pb_plugin,
+				"scan", dev->mount_path,
+				NULL);
+	if (rc)
+		pb_log("Error from pb-plugin scan %s\n",
+				dev->mount_path);
+}
+
 void device_handler_status_download_remove(struct device_handler *handler,
 		struct process_info *procinfo)
 {
@@ -618,7 +712,17 @@ void device_handler_status_download_remove(struct device_handler *handler,
 
 static void device_handler_boot_status_cb(void *arg, struct status *status)
 {
-	device_handler_status(arg, status);
+	struct device_handler *handler = arg;
+
+	/* boot had failed; update handler state to allow a new default if one
+	 * is found later
+	 */
+	if (status->type == STATUS_ERROR) {
+		handler->pending_boot = NULL;
+		handler->default_boot_option = NULL;
+	}
+
+	device_handler_status(handler, status);
 }
 
 static void countdown_status(struct device_handler *handler,
@@ -628,7 +732,8 @@ static void countdown_status(struct device_handler *handler,
 
 	status.type = STATUS_INFO;
 	status.message = talloc_asprintf(handler,
-			_("Booting in %d sec: %s"), sec, opt->option->name);
+			_("Booting in %d sec: [%s] %s"), sec,
+			opt->device->device->id, opt->option->name);
 	status.backlog = false;
 
 	device_handler_status(handler, &status);
@@ -694,24 +799,31 @@ static bool ipmi_device_type_matches(enum ipmi_bootdev ipmi_type,
 	return false;
 }
 
+static bool autoboot_option_matches(struct autoboot_option *opt,
+		struct discover_device *dev)
+{
+	if (opt->boot_type == BOOT_DEVICE_UUID)
+		if (!strcmp(opt->uuid, dev->uuid))
+			return true;
+
+	if (opt->boot_type == BOOT_DEVICE_TYPE)
+		if (opt->type == dev->device->type ||
+		    opt->type == DEVICE_TYPE_ANY)
+			return true;
+
+	return false;
+}
+
 static int autoboot_option_priority(const struct config *config,
 				struct discover_boot_option *opt)
 {
-	enum device_type type = opt->device->device->type;
-	const char *uuid = opt->device->uuid;
 	struct autoboot_option *auto_opt;
 	unsigned int i;
 
 	for (i = 0; i < config->n_autoboot_opts; i++) {
 		auto_opt = &config->autoboot_opts[i];
-		if (auto_opt->boot_type == BOOT_DEVICE_UUID)
-			if (!strcmp(auto_opt->uuid, uuid))
-				return DEFAULT_PRIORITY_LOCAL_FIRST + i;
-
-		if (auto_opt->boot_type == BOOT_DEVICE_TYPE)
-			if (auto_opt->type == type ||
-			    auto_opt->type == DEVICE_TYPE_ANY)
-				return DEFAULT_PRIORITY_LOCAL_FIRST + i;
+		if (autoboot_option_matches(auto_opt, opt->device))
+			return DEFAULT_PRIORITY_LOCAL_FIRST + i;
 	}
 
 	return -1;
@@ -723,15 +835,27 @@ static int autoboot_option_priority(const struct config *config,
  * for these options.
  */
 static enum default_priority default_option_priority(
+		struct device_handler *handler,
 		struct discover_boot_option *opt)
 {
 	const struct config *config;
 
+	/* Temporary user-provided autoboot options have highest priority */
+	if (handler->temp_autoboot) {
+		if (autoboot_option_matches(handler->temp_autoboot,
+					opt->device))
+			return DEFAULT_PRIORITY_TEMP_USER;
+
+		pb_debug("handler: disabled default priority due to "
+				"temporary user override\n");
+		return DEFAULT_PRIORITY_DISABLED;
+	}
+
 	config = config_get();
 
-	/* We give highest priority to IPMI-configured boot options. If
-	 * we have an IPMI bootdev configuration set, then we don't allow
-	 * any other defaults */
+	/* Next highest priority to IPMI-configured boot options. If we have an
+	 * IPMI bootdev configuration set, then we don't allow any other
+	 * defaults */
 	if (config->ipmi_bootdev) {
 		bool ipmi_match = ipmi_device_type_matches(config->ipmi_bootdev,
 				opt->device->device->type);
@@ -750,6 +874,9 @@ static enum default_priority default_option_priority(
 		int boot_match = autoboot_option_priority(config, opt);
 		if (boot_match > 0)
 			return boot_match;
+	} else {
+		/* If there is no specific boot order, boot any device */
+		return DEFAULT_PRIORITY_LOCAL_FIRST;
 	}
 
 	/* If the option didn't match any entry in the array, it is disabled */
@@ -768,7 +895,7 @@ static void set_default(struct device_handler *handler,
 
 	pb_debug("handler: new default option: %s\n", opt->option->id);
 
-	new_prio = default_option_priority(opt);
+	new_prio = default_option_priority(handler, opt);
 
 	/* Anything outside our range prevents a default boot */
 	if (new_prio >= DEFAULT_PRIORITY_DISABLED)
@@ -808,6 +935,43 @@ static void set_default(struct device_handler *handler,
 	default_timeout(handler);
 }
 
+void device_handler_apply_temp_autoboot(struct device_handler *handler,
+		struct autoboot_option *opt)
+{
+	unsigned int i;
+
+	handler->temp_autoboot = talloc_steal(handler, opt);
+
+	if (!handler->autoboot_enabled)
+		return;
+
+	if (!handler->default_boot_option)
+		return;
+
+	if (autoboot_option_matches(opt, handler->default_boot_option->device))
+		return;
+
+	/* cancel the default, and rescan available options */
+	device_handler_cancel_default(handler);
+
+	handler->autoboot_enabled = true;
+
+	for (i = 0; i < handler->n_devices; i++) {
+		struct discover_device *dev = handler->devices[i];
+		struct discover_boot_option *boot_opt;
+
+		if (!autoboot_option_matches(opt, dev))
+			continue;
+
+		list_for_each_entry(&dev->boot_options, boot_opt, list) {
+			if (boot_opt->option->is_default) {
+				set_default(handler, boot_opt);
+				break;
+			}
+		}
+	}
+}
+
 static bool resource_is_resolved(struct resource *res)
 {
 	return !res || res->resolved;
@@ -1068,12 +1232,118 @@ int device_handler_discover(struct device_handler *handler,
 	device_handler_discover_context_commit(handler, ctx);
 
 	process_boot_option_queue(handler);
+
+	/* Check this device for pb-plugins */
+	device_handler_plugin_scan_device(handler, dev);
 out:
 	talloc_unlink(handler, ctx);
 
 	return 0;
 }
 
+struct requery_data {
+	struct device_handler	*handler;
+	struct discover_device	*device;
+};
+
+static int device_handler_requery_timeout_fn(void *data)
+{
+	struct discover_boot_option *opt, *tmp;
+	struct requery_data *rqd = data;
+	struct device_handler *handler;
+	struct discover_device *device;
+
+	handler = rqd->handler;
+	device = rqd->device;
+
+	talloc_free(rqd);
+
+	/* network_requery_device may re-add a timeout, so clear the device
+	 * waiter here, so we can potentially start a new one. */
+	device->requery_waiter = NULL;
+
+	/* We keep the device around, but get rid of the parsed boot
+	 * options on that device. That involves delaring out the lists,
+	 * and potentially cancelling a default.
+	 */
+	list_for_each_entry_safe(&handler->unresolved_boot_options,
+			opt, tmp, list) {
+		if (opt->device != device)
+			continue;
+		list_remove(&opt->list);
+		talloc_free(opt);
+	}
+
+	list_for_each_entry_safe(&device->boot_options, opt, tmp, list) {
+		if (opt == handler->default_boot_option) {
+			pb_log("Default option %s cancelled since device is being requeried",
+					opt->option->name);
+			device_handler_cancel_default(handler);
+		}
+		list_remove(&opt->list);
+		talloc_free(opt);
+	}
+
+	discover_server_notify_device_remove(handler->server, device->device);
+	device->notified = false;
+
+	network_requery_device(handler->network, device);
+
+	return 0;
+}
+
+/* Schedule a requery in timeout (seconds).
+ *
+ * Special values of timeout:
+ *   0: no requery
+ *  -1: use default
+ */
+void device_handler_start_requery_timeout( struct device_handler *handler,
+		struct discover_device *dev, int timeout)
+{
+	struct requery_data *rqd;
+
+	if (dev->requery_waiter)
+		return;
+
+	if (timeout == -1)
+		timeout = default_rescan_timeout;
+	else if (timeout == 0)
+		return;
+
+	rqd = talloc(dev, struct requery_data);
+	rqd->handler = handler;
+	rqd->device = dev;
+
+	pb_debug("starting requery timeout for device %s, in %d sec\n",
+			dev->device->id, timeout);
+
+	dev->requery_waiter = waiter_register_timeout(handler->waitset,
+			timeout * 1000, device_handler_requery_timeout_fn, rqd);
+}
+
+static int event_requery_timeout(struct event *event)
+{
+	int timeout = -1;
+	unsigned long x;
+	const char *str;
+	char *endp;
+
+	if (!event)
+		return timeout;
+
+	str = event_get_param(event, "reboottime");
+	if (!str)
+		return timeout;
+
+	x = strtoul(str, &endp, 0);
+	if (endp != str)
+		timeout = x;
+
+	return timeout;
+}
+
+
 /* Incoming dhcp event */
 int device_handler_dhcp(struct device_handler *handler,
 		struct discover_device *dev, struct event *event)
@@ -1091,6 +1361,9 @@ int device_handler_dhcp(struct device_handler *handler,
 	talloc_steal(ctx, event);
 	ctx->event = event;
 
+	device_handler_start_requery_timeout(handler, dev,
+			event_requery_timeout(event));
+
 	iterate_parsers(ctx);
 
 	device_handler_discover_context_commit(handler, ctx);
@@ -1244,62 +1517,101 @@ static char *device_from_addr(void *ctx, struct pb_url *url)
 	return dev;
 }
 
+static void process_url_cb(struct load_url_result *result, void *data)
+{
+	struct device_handler *handler;
+	struct discover_context *ctx;
+	struct discover_device *dev;
+	struct event *event = data;
+	const char *mac;
+
+	if (result->status != LOAD_OK) {
+		pb_log("%s: Load failed for %s\n", __func__, result->url->full);
+		return;
+	}
+
+	if (!event)
+		return;
+
+	handler = talloc_parent(event);
+	if (!handler)
+		return;
+
+	event->device = device_from_addr(event, result->url);
+	if (!event->device) {
+		pb_log("Downloaded a file but can't find its interface - pretending it was local\n");
+		event->device = talloc_asprintf(event, "local");
+	}
+
+	mac = event_get_param(event, "mac");
+	char *url = talloc_asprintf(event, "file://%s", result->local);
+	event_set_param(event, "pxeconffile-local", url);
+
+	dev = discover_device_create(handler, mac, event->device);
+	ctx = device_handler_discover_context_create(handler, dev);
+	talloc_steal(ctx, event);
+	ctx->event = event;
+
+	iterate_parsers(ctx);
+
+	device_handler_discover_context_commit(handler, ctx);
+
+	talloc_unlink(handler, ctx);
+}
+
 void device_handler_process_url(struct device_handler *handler,
 		const char *url, const char *mac, const char *ip)
 {
 	struct discover_context *ctx;
 	struct discover_device *dev;
+	bool allow_async = false;
 	struct pb_url *pb_url;
 	struct event *event;
-	struct param *param;
 
-	if (!handler->network) {
-		device_handler_status_err(handler, _("No network configured"));
-		return;
-	}
-
-	event = talloc(handler, struct event);
+	event = talloc_zero(handler, struct event);
 	event->type = EVENT_TYPE_USER;
 	event->action = EVENT_ACTION_URL;
 
-	if (url[strlen(url) - 1] == '/') {
-		event->params = talloc_array(event, struct param, 3);
-		param = &event->params[0];
-		param->name = talloc_strdup(event, "pxepathprefix");
-		param->value = talloc_strdup(event, url);
-		param = &event->params[1];
-		param->name = talloc_strdup(event, "mac");
-		param->value = talloc_strdup(event, mac);
-		param = &event->params[2];
-		param->name = talloc_strdup(event, "ip");
-		param->value = talloc_strdup(event, ip);
-		event->n_params = 3;
-	} else {
-		event->params = talloc_array(event, struct param, 1);
-		param = &event->params[0];
-		param->name = talloc_strdup(event, "pxeconffile");
-		param->value = talloc_strdup(event, url);
-		event->n_params = 1;
-	}
-
-	pb_url = pb_url_parse(event, event->params->value);
+	pb_url = pb_url_parse(event, url);
 	if (!pb_url || (pb_url->scheme != pb_url_file && !pb_url->host)) {
 		device_handler_status_err(handler, _("Invalid config URL!"));
+		talloc_free(event);
 		return;
 	}
 
-	if (pb_url->scheme == pb_url_file)
-		event->device = talloc_asprintf(event, "local");
-	else
+	if (url[strlen(url) - 1] == '/') {
+		event_set_param(event, "pxepathprefix", url);
+		event_set_param(event, "mac", mac);
+		event_set_param(event, "ip", ip);
 		event->device = device_from_addr(event, pb_url);
-
-	if (!event->device) {
-		device_handler_status_err(handler,
+		if (!event->device) {
+			device_handler_status_err(handler,
 					_("Unable to route to host %s"),
 					pb_url->host);
+			talloc_free(event);
+			return;
+		}
+	} else {
+		event_set_param(event, "pxeconffile", url);
+		allow_async = true;
+	}
+
+	if (pb_url->scheme == pb_url_file)
+		event->device = talloc_asprintf(event, "local");
+	else if (allow_async) {
+		/* If file is remote load asynchronously before passing to
+		 * parser. This allows us to wait for network to be available */
+		if (!load_url_async(handler, pb_url, process_url_cb, event,
+					NULL, handler)) {
+			pb_log("Failed to load url %s\n", pb_url->full);
+			device_handler_status_err(handler, _("Failed to load URL!"));
+			talloc_free(event);
+		}
 		return;
 	}
 
+	/* If path is local we can parse straight away */
+
 	dev = discover_device_create(handler, mac, event->device);
 	if (pb_url->scheme == pb_url_file)
 		dev->device->type = DEVICE_TYPE_ANY;
@@ -1314,6 +1626,61 @@ void device_handler_process_url(struct device_handler *handler,
 	talloc_unlink(handler, ctx);
 }
 
+static void plugin_install_cb(struct process *process)
+{
+	struct device_handler *handler = process->data;
+
+	if (!handler) {
+		pb_log("%s: Missing data!\n", __func__);
+		return;
+	}
+
+	handler->plugin_installing = false;
+	if (process->exit_status) {
+		device_handler_status_err(handler, "Plugin failed to install!");
+		pb_log("Failed to install plugin:\n%s\n", process->stdout_buf);
+	}
+}
+
+void device_handler_install_plugin(struct device_handler *handler,
+		const char *plugin_file)
+{
+	struct process *p;
+	int result;
+
+	if (handler->plugin_installing) {
+		pb_log("Plugin install cancelled - install already running");
+		return;
+	}
+
+	p = process_create(handler);
+	if (!p) {
+		pb_log("install_plugin: Failed to create process\n");
+		return;
+	}
+
+	const char *argv[] = {
+		pb_system_apps.pb_plugin,
+		"install",
+		"auto",
+		plugin_file,
+		NULL
+	};
+
+	p->path = pb_system_apps.pb_plugin;
+	p->argv = argv;
+	p->exit_cb = plugin_install_cb;
+	p->data = handler;
+	p->keep_stdout = true;
+
+	result = process_run_async(p);
+
+	if (result)
+		device_handler_status_err(handler, "Could not install plugin");
+	else
+		handler->plugin_installing = true;
+}
+
 #ifndef PETITBOOT_TEST
 
 /**
@@ -1368,6 +1735,35 @@ void device_handler_discover_context_commit(struct device_handler *handler,
 	}
 }
 
+void device_handler_add_plugin_option(struct device_handler *handler,
+		struct plugin_option *opt)
+{
+	struct plugin_option *tmp;
+	unsigned int i;
+
+	for (i = 0; i < handler->n_plugins; i++) {
+		tmp = handler->plugins[i];
+		/* If both id and version match, ignore */
+		if (strncmp(opt->id, tmp->id, strlen(opt->id)) == 0 &&
+				strcmp(opt->version, tmp->version) == 0) {
+			pb_log("discover: Plugin '%s' already exists, ignoring\n",
+					opt->id);
+			return;
+		}
+	}
+
+	handler->plugins = talloc_realloc(handler, handler->plugins,
+			struct plugin_option *, handler->n_plugins + 1);
+	if (!handler->plugins) {
+		pb_log("Failed to allocate memory for new plugin\n");
+		handler->n_plugins = 0;
+		return;
+	}
+
+	handler->plugins[handler->n_plugins++] = opt;
+	discover_server_notify_plugin_option_add(handler->server, opt);
+}
+
 static void device_handler_update_lang(const char *lang)
 {
 	const char *cur_lang;
@@ -1385,8 +1781,8 @@ static void device_handler_update_lang(const char *lang)
 static int device_handler_init_sources(struct device_handler *handler)
 {
 	/* init our device sources: udev, network and user events */
-	handler->udev = udev_init(handler, handler->waitset);
-	if (!handler->udev)
+	handler->user_event = user_event_init(handler, handler->waitset);
+	if (!handler->user_event)
 		return -1;
 
 	handler->network = network_init(handler, handler->waitset,
@@ -1394,8 +1790,8 @@ static int device_handler_init_sources(struct device_handler *handler)
 	if (!handler->network)
 		return -1;
 
-	handler->user_event = user_event_init(handler, handler->waitset);
-	if (!handler->user_event)
+	handler->udev = udev_init(handler, handler->waitset);
+	if (!handler->udev)
 		return -1;
 
 	return 0;
@@ -1412,11 +1808,11 @@ static void device_handler_reinit_sources(struct device_handler *handler)
 
 	system_info_reinit();
 
-	udev_reinit(handler->udev);
-
 	network_shutdown(handler->network);
 	handler->network = network_init(handler, handler->waitset,
 			handler->dry_run);
+
+	udev_reinit(handler->udev);
 }
 
 static inline const char *get_device_path(struct discover_device *dev)
@@ -1584,6 +1980,20 @@ static int mount_device(struct discover_device *dev)
 	rc = try_mount(device_path, dev->mount_path, fstype,
 		       MS_RDONLY | MS_SILENT, dev->ramdisk);
 
+	/* If mount fails clean up any snapshot and try again */
+	if (rc && dev->ramdisk) {
+		pb_log("couldn't mount snapshot for %s: mount failed: %s\n",
+				device_path, strerror(errno));
+		pb_log("falling back to actual device\n");
+
+		devmapper_destroy_snapshot(dev);
+
+		device_path = get_device_path(dev);
+		pb_log("mounting device %s read-only\n", dev->device_path);
+		rc = try_mount(device_path, dev->mount_path, fstype,
+			       MS_RDONLY | MS_SILENT, dev->ramdisk);
+	}
+
 	if (!rc) {
 		dev->mounted = true;
 		dev->mounted_rw = false;
@@ -1595,9 +2005,6 @@ static int mount_device(struct discover_device *dev)
 	pb_log("couldn't mount device %s: mount failed: %s\n",
 			device_path, strerror(errno));
 
-	/* If mount fails clean up any snapshot */
-	devmapper_destroy_snapshot(dev);
-
 	pb_rmdir_recursive(mount_base(), dev->mount_path);
 err_free:
 	talloc_free(dev->mount_path);