X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Fudevd.c;h=fe0e3c39295724776a71f248eaf13ef4df5f3fab;hp=292f4374d7560c4d3d54dcd011bcbd502549acda;hb=5f59fa0900a5c127ce1a25d8ba3176f166662f96;hpb=9060b066d9e7aaca9795010ac5fff61018947f87

diff --git a/udev/udevd.c b/udev/udevd.c
index 292f4374d..fe0e3c392 100644
--- a/udev/udevd.c
+++ b/udev/udevd.c
@@ -24,14 +24,17 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>
 #include <ctype.h>
 #include <fcntl.h>
 #include <time.h>
 #include <getopt.h>
 #include <dirent.h>
+#include <sys/time.h>
 #include <sys/prctl.h>
 #include <sys/socket.h>
+#include <sys/un.h>
 #include <sys/signalfd.h>
 #include <sys/select.h>
 #include <sys/poll.h>
@@ -39,40 +42,50 @@
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/inotify.h>
+#include <sys/utsname.h>
 
 #include "udev.h"
+#include "sd-daemon.h"
 
 #define UDEVD_PRIORITY			-4
 #define UDEV_PRIORITY			-2
 
-static int debug;
+static bool debug;
 
 static void log_fn(struct udev *udev, int priority,
 		   const char *file, int line, const char *fn,
 		   const char *format, va_list args)
 {
 	if (debug) {
-		fprintf(stderr, "[%d] %s: ", (int) getpid(), fn);
-		vfprintf(stderr, format, args);
+		char buf[1024];
+		struct timeval tv;
+		struct timezone tz;
+
+		vsnprintf(buf, sizeof(buf), format, args);
+		gettimeofday(&tv, &tz);
+		fprintf(stderr, "%llu.%06u [%u] %s: %s",
+			(unsigned long long) tv.tv_sec, (unsigned int) tv.tv_usec,
+			(int) getpid(), fn, buf);
 	} else {
 		vsyslog(priority, format, args);
 	}
 }
 
-static int debug_trace;
 static struct udev_rules *rules;
 static struct udev_queue_export *udev_queue_export;
 static struct udev_ctrl *udev_ctrl;
 static struct udev_monitor *monitor;
 static int worker_watch[2];
 static pid_t settle_pid;
-static int stop_exec_queue;
-static int reload_config;
-static int max_childs;
-static int childs;
+static bool stop_exec_queue;
+static bool reload_config;
+static int children;
+static int children_max;
+static int exec_delay;
+static sigset_t orig_sigmask;
 static struct udev_list_node event_list;
 static struct udev_list_node worker_list;
-static int udev_exit;
+static bool udev_exit;
 static volatile sig_atomic_t worker_exit;
 
 enum poll_fd {
@@ -108,6 +121,9 @@ struct event {
 	const char *devpath;
 	size_t devpath_len;
 	const char *devpath_old;
+	dev_t devnum;
+	bool is_block;
+	int ifindex;
 };
 
 static struct event *node_to_event(struct udev_list_node *node)
@@ -128,6 +144,8 @@ enum worker_state {
 
 struct worker {
 	struct udev_list_node node;
+	struct udev *udev;
+	int refcount;
 	pid_t pid;
 	struct udev_monitor *monitor;
 	enum worker_state state;
@@ -154,7 +172,7 @@ static void event_queue_delete(struct event *event)
 	udev_list_node_remove(&event->node);
 
 	/* mark as failed, if "add" event returns non-zero */
-	if (event->exitcode && strcmp(udev_device_get_action(event->dev), "add") == 0)
+	if (event->exitcode != 0 && strcmp(udev_device_get_action(event->dev), "remove") != 0)
 		udev_queue_export_device_failed(udev_queue_export, event->dev);
 	else
 		udev_queue_export_device_finished(udev_queue_export, event->dev);
@@ -171,14 +189,27 @@ static void event_sig_handler(int signum)
 		_exit(1);
 		break;
 	case SIGTERM:
-		worker_exit = 1;
+		worker_exit = true;
 		break;
 	}
 }
 
+static struct worker *worker_ref(struct worker *worker)
+{
+	worker->refcount++;
+	return worker;
+}
+
 static void worker_unref(struct worker *worker)
 {
+	worker->refcount--;
+	if (worker->refcount > 0)
+		return;
+
+	udev_list_node_remove(&worker->node);
 	udev_monitor_unref(worker->monitor);
+	children--;
+	info(worker->udev, "worker [%u] cleaned up\n", worker->pid);
 	free(worker);
 }
 
@@ -196,17 +227,25 @@ static void worker_new(struct event *event)
 	/* allow the main daemon netlink address to send devices to the worker */
 	udev_monitor_allow_unicast_sender(worker_monitor, monitor);
 	udev_monitor_enable_receiving(worker_monitor);
-	util_set_fd_cloexec(udev_monitor_get_fd(worker_monitor));
 
 	worker = calloc(1, sizeof(struct worker));
-	if (worker == NULL)
+	if (worker == NULL) {
+		udev_monitor_unref(worker_monitor);
 		return;
+	}
+	/* worker + event reference */
+	worker->refcount = 2;
+	worker->udev = event->udev;
 
 	pid = fork();
 	switch (pid) {
 	case 0: {
-		sigset_t mask;
+		sigset_t sigmask;
 		struct udev_device *dev;
+		struct pollfd pmon = {
+			.fd = udev_monitor_get_fd(worker_monitor),
+			.events = POLLIN,
+		};
 
 		udev_queue_export_unref(udev_queue_export);
 		udev_monitor_unref(monitor);
@@ -225,11 +264,12 @@ static void worker_new(struct event *event)
 		sigaction(SIGTERM, &act, NULL);
 		sigaction(SIGALRM, &act, NULL);
 
-		/* unblock signals */
-		sigfillset(&mask);
-		sigdelset(&mask, SIGTERM);
-		sigdelset(&mask, SIGALRM);
-		sigprocmask(SIG_SETMASK, &mask, NULL);
+		/* unblock SIGALRM */
+		sigfillset(&sigmask);
+		sigdelset(&sigmask, SIGALRM);
+		sigprocmask(SIG_SETMASK, &sigmask, NULL);
+		/* SIGTERM is unblocked in ppoll() */
+		sigdelset(&sigmask, SIGTERM);
 
 		/* request TERM signal if parent exits */
 		prctl(PR_SET_PDEATHSIG, SIGTERM);
@@ -237,11 +277,13 @@ static void worker_new(struct event *event)
 		/* initial device */
 		dev = event->dev;
 
-		while (!worker_exit) {
+		do {
 			struct udev_event *udev_event;
-			struct worker_message msg;
+			struct worker_message msg = {};
 			int err;
+			int failed = 0;
 
+			info(event->udev, "seq %llu running\n", udev_device_get_seqnum(dev));
 			udev_event = udev_event_new(dev);
 			if (udev_event == NULL)
 				_exit(3);
@@ -249,6 +291,9 @@ static void worker_new(struct event *event)
 			/* set timeout to prevent hanging processes */
 			alarm(UDEV_EVENT_TIMEOUT);
 
+			if (exec_delay > 0)
+				udev_event->exec_delay = exec_delay;
+
 			/* apply rules, create node, symlinks */
 			err = udev_event_execute_rules(udev_event, rules);
 
@@ -256,11 +301,9 @@ static void worker_new(struct event *event)
 			if (udev_device_get_event_timeout(dev) >= 0)
 				alarm(udev_device_get_event_timeout(dev));
 
-			/* execute RUN= */
-			if (err == 0 && !udev_event->ignore_device && udev_get_run(udev_event->udev))
-				udev_event_execute_run(udev_event);
+			if (err == 0)
+				failed = udev_event_execute_run(udev_event, &orig_sigmask);
 
-			/* reset alarm */
 			alarm(0);
 
 			/* apply/restore inotify watch */
@@ -272,20 +315,34 @@ static void worker_new(struct event *event)
 			/* send processed event back to libudev listeners */
 			udev_monitor_send_device(worker_monitor, NULL, dev);
 
+			/* send udevd the result of the event execution */
+			if (err != 0)
+				msg.exitcode = err;
+			else if (failed != 0)
+				msg.exitcode = failed;
+			msg.pid = getpid();
+			send(worker_watch[WRITE_END], &msg, sizeof(struct worker_message), 0);
+
 			info(event->udev, "seq %llu processed with %i\n", udev_device_get_seqnum(dev), err);
-			udev_device_unref(dev);
 			udev_event_unref(udev_event);
+			udev_device_unref(dev);
+			dev = NULL;
 
-			/* send back the result of the event execution */
-			msg.exitcode = err;
-			msg.pid = getpid();
-			send(worker_watch[WRITE_END], &msg, sizeof(struct worker_message), 0);
+			/* wait for more device messages or signal from udevd */
+			while (!worker_exit) {
+				int fdcount;
 
-			/* wait for more device messages from udevd */
-			do
-				dev = udev_monitor_receive_device(worker_monitor);
-			while (!worker_exit && dev == NULL);
-		}
+				fdcount = ppoll(&pmon, 1, NULL, &sigmask);
+				if (fdcount < 0)
+					continue;
+
+				if (pmon.revents & POLLIN) {
+					dev = udev_monitor_receive_device(worker_monitor);
+					if (dev != NULL)
+						break;
+				}
+			}
+		} while (dev != NULL);
 
 		udev_monitor_unref(worker_monitor);
 		udev_log_close();
@@ -306,13 +363,13 @@ static void worker_new(struct event *event)
 		worker->event = event;
 		event->state = EVENT_RUNNING;
 		udev_list_node_append(&worker->node, &worker_list);
-		childs++;
+		children++;
 		info(event->udev, "seq %llu forked new worker [%u]\n", udev_device_get_seqnum(event->dev), pid);
 		break;
 	}
 }
 
-static void event_run(struct event *event)
+static void event_run(struct event *event, bool force)
 {
 	struct udev_list_node *loop;
 
@@ -323,22 +380,23 @@ static void event_run(struct event *event)
 		if (worker->state != WORKER_IDLE)
 			continue;
 
-		worker->event = event;
-		worker->state = WORKER_RUNNING;
-		event->state = EVENT_RUNNING;
 		count = udev_monitor_send_device(monitor, worker->monitor, event->dev);
 		if (count < 0) {
-			err(event->udev, "worker [%u] did not accept message, kill it\n", worker->pid);
-			event->state = EVENT_QUEUED;
-			worker->state = WORKER_KILLED;
+			err(event->udev, "worker [%u] did not accept message %zi (%m), kill it\n", worker->pid, count);
 			kill(worker->pid, SIGKILL);
+			worker->state = WORKER_KILLED;
 			continue;
 		}
+		worker_ref(worker);
+		worker->event = event;
+		worker->state = WORKER_RUNNING;
+		event->state = EVENT_RUNNING;
 		return;
 	}
 
-	if (childs >= max_childs) {
-		info(event->udev, "maximum number (%i) of childs reached\n", childs);
+	if (!force && children >= children_max) {
+		if (children_max > 1)
+			info(event->udev, "maximum number (%i) of children reached\n", children);
 		return;
 	}
 
@@ -346,13 +404,13 @@ static void event_run(struct event *event)
 	worker_new(event);
 }
 
-static void event_queue_insert(struct udev_device *dev)
+static int event_queue_insert(struct udev_device *dev)
 {
 	struct event *event;
 
 	event = calloc(1, sizeof(struct event));
 	if (event == NULL)
-		return;
+		return -1;
 
 	event->udev = udev_device_get_udev(dev);
 	event->dev = dev;
@@ -360,6 +418,9 @@ static void event_queue_insert(struct udev_device *dev)
 	event->devpath = udev_device_get_devpath(dev);
 	event->devpath_len = strlen(event->devpath);
 	event->devpath_old = udev_device_get_devpath_old(dev);
+	event->devnum = udev_device_get_devnum(dev);
+	event->is_block = (strcmp("block", udev_device_get_subsystem(dev)) == 0);
+	event->ifindex = udev_device_get_ifindex(dev);
 
 	udev_queue_export_device_queued(udev_queue_export, dev);
 	info(event->udev, "seq %llu queued, '%s' '%s'\n", udev_device_get_seqnum(dev),
@@ -370,20 +431,22 @@ static void event_queue_insert(struct udev_device *dev)
 
 	/* run all events with a timeout set immediately */
 	if (udev_device_get_timeout(dev) > 0) {
-		worker_new(event);
-		return;
+		event_run(event, true);
+		return 0;
 	}
+
+	return 0;
 }
 
-static void worker_kill(int retain)
+static void worker_kill(struct udev *udev, int retain)
 {
 	struct udev_list_node *loop;
 	int max;
 
-	if (childs <= retain)
+	if (children <= retain)
 		return;
 
-	max = childs - retain;
+	max = children - retain;
 
 	udev_list_node_foreach(loop, &worker_list) {
 		struct worker *worker = node_to_worker(loop);
@@ -399,31 +462,8 @@ static void worker_kill(int retain)
 	}
 }
 
-static int mem_size_mb(void)
-{
-	FILE *f;
-	char buf[4096];
-	long int memsize = -1;
-
-	f = fopen("/proc/meminfo", "r");
-	if (f == NULL)
-		return -1;
-
-	while (fgets(buf, sizeof(buf), f) != NULL) {
-		long int value;
-
-		if (sscanf(buf, "MemTotal: %ld kB", &value) == 1) {
-			memsize = value / 1024;
-			break;
-		}
-	}
-
-	fclose(f);
-	return memsize;
-}
-
 /* lookup event for identical, parent, child device */
-static int devpath_busy(struct event *event)
+static bool is_devpath_busy(struct event *event)
 {
 	struct udev_list_node *loop;
 	size_t common;
@@ -438,18 +478,25 @@ static int devpath_busy(struct event *event)
 
 		/* event we checked earlier still exists, no need to check again */
 		if (loop_event->seqnum == event->delaying_seqnum)
-			return 2;
+			return true;
 
 		/* found ourself, no later event can block us */
 		if (loop_event->seqnum >= event->seqnum)
 			break;
 
+		/* check major/minor */
+		if (major(event->devnum) != 0 && event->devnum == loop_event->devnum && event->is_block == loop_event->is_block)
+			return true;
+
+		/* check network device ifindex */
+		if (event->ifindex != 0 && event->ifindex == loop_event->ifindex)
+			return true;
+
 		/* check our old name */
-		if (event->devpath_old != NULL)
-			if (strcmp(loop_event->devpath, event->devpath_old) == 0) {
-				event->delaying_seqnum = loop_event->seqnum;
-				return 3;
-			}
+		if (event->devpath_old != NULL && strcmp(loop_event->devpath, event->devpath_old) == 0) {
+			event->delaying_seqnum = loop_event->seqnum;
+			return true;
+		}
 
 		/* compare devpath */
 		common = MIN(loop_event->devpath_len, event->devpath_len);
@@ -460,27 +507,32 @@ static int devpath_busy(struct event *event)
 
 		/* identical device event found */
 		if (loop_event->devpath_len == event->devpath_len) {
+			/* devices names might have changed/swapped in the meantime */
+			if (major(event->devnum) != 0 && (event->devnum != loop_event->devnum || event->is_block != loop_event->is_block))
+				continue;
+			if (event->ifindex != 0 && event->ifindex != loop_event->ifindex)
+				continue;
 			event->delaying_seqnum = loop_event->seqnum;
-			return 4;
+			return true;
 		}
 
 		/* parent device event found */
 		if (event->devpath[common] == '/') {
 			event->delaying_seqnum = loop_event->seqnum;
-			return 5;
+			return true;
 		}
 
 		/* child device event found */
 		if (loop_event->devpath[common] == '/') {
 			event->delaying_seqnum = loop_event->seqnum;
-			return 6;
+			return true;
 		}
 
 		/* no matching device */
 		continue;
 	}
 
-	return 0;
+	return false;
 }
 
 static void events_start(struct udev *udev)
@@ -494,18 +546,18 @@ static void events_start(struct udev *udev)
 			continue;
 
 		/* do not start event if parent or child event is still running */
-		if (devpath_busy(event) != 0) {
+		if (is_devpath_busy(event)) {
 			dbg(udev, "delay seq %llu (%s)\n", event->seqnum, event->devpath);
 			continue;
 		}
 
-		event_run(event);
+		event_run(event, false);
 	}
 }
 
 static void worker_returned(void)
 {
-	while (1) {
+	for (;;) {
 		struct worker_message msg;
 		ssize_t size;
 		struct udev_list_node *loop;
@@ -525,7 +577,9 @@ static void worker_returned(void)
 			worker->event->exitcode = msg.exitcode;
 			event_queue_delete(worker->event);
 			worker->event = NULL;
-			worker->state = WORKER_IDLE;
+			if (worker->state != WORKER_KILLED)
+				worker->state = WORKER_IDLE;
+			worker_unref(worker);
 			break;
 		}
 	}
@@ -547,22 +601,22 @@ static void handle_ctrl_msg(struct udev_ctrl *uctrl)
 	if (i >= 0) {
 		info(udev, "udevd message (SET_LOG_PRIORITY) received, log_priority=%i\n", i);
 		udev_set_log_priority(udev, i);
-		worker_kill(0);
+		worker_kill(udev, 0);
 	}
 
 	if (udev_ctrl_get_stop_exec_queue(ctrl_msg) > 0) {
 		info(udev, "udevd message (STOP_EXEC_QUEUE) received\n");
-		stop_exec_queue = 1;
+		stop_exec_queue = true;
 	}
 
 	if (udev_ctrl_get_start_exec_queue(ctrl_msg) > 0) {
 		info(udev, "udevd message (START_EXEC_QUEUE) received\n");
-		stop_exec_queue = 0;
+		stop_exec_queue = false;
 	}
 
 	if (udev_ctrl_get_reload_rules(ctrl_msg) > 0) {
 		info(udev, "udevd message (RELOAD_RULES) received\n");
-		reload_config = 1;
+		reload_config = true;
 	}
 
 	str = udev_ctrl_get_set_env(ctrl_msg);
@@ -589,13 +643,13 @@ static void handle_ctrl_msg(struct udev_ctrl *uctrl)
 			}
 			free(key);
 		}
-		worker_kill(0);
+		worker_kill(udev, 0);
 	}
 
-	i = udev_ctrl_get_set_max_childs(ctrl_msg);
+	i = udev_ctrl_get_set_children_max(ctrl_msg);
 	if (i >= 0) {
-		info(udev, "udevd message (SET_MAX_CHILDS) received, max_childs=%i\n", i);
-		max_childs = i;
+		info(udev, "udevd message (SET_MAX_CHILDREN) received, children_max=%i\n", i);
+		children_max = i;
 	}
 
 	settle_pid = udev_ctrl_get_settle(ctrl_msg);
@@ -610,7 +664,7 @@ static void handle_ctrl_msg(struct udev_ctrl *uctrl)
 /* read inotify messages */
 static int handle_inotify(struct udev *udev)
 {
-	ssize_t nbytes, pos;
+	int nbytes, pos;
 	char *buf;
 	struct inotify_event *ev;
 
@@ -630,14 +684,21 @@ static int handle_inotify(struct udev *udev)
 
 		ev = (struct inotify_event *)(buf + pos);
 		if (ev->len) {
-			dbg(udev, "inotify event: %x for %s\n", ev->mask, ev->name);
-			reload_config = 1;
+			const char *s;
+
+			info(udev, "inotify event: %x for %s\n", ev->mask, ev->name);
+			s = strstr(ev->name, ".rules");
+			if (s == NULL)
+				continue;
+			if (strlen(s) != strlen(".rules"))
+				continue;
+			reload_config = true;
 			continue;
 		}
 
 		dev = udev_watch_lookup(udev, ev->wd);
 		if (dev != NULL) {
-			dbg(udev, "inotify event: %x for %s\n", ev->mask, udev_device_get_devnode(dev));
+			info(udev, "inotify event: %x for %s\n", ev->mask, udev_device_get_devnode(dev));
 			if (ev->mask & IN_CLOSE_WRITE) {
 				char filename[UTIL_PATH_SIZE];
 				int fd;
@@ -666,10 +727,10 @@ static void handle_signal(struct udev *udev, int signo)
 	switch (signo) {
 	case SIGINT:
 	case SIGTERM:
-		udev_exit = 1;
+		udev_exit = true;
 		break;
 	case SIGCHLD:
-		while (1) {
+		for (;;) {
 			pid_t pid;
 			int status;
 			struct udev_list_node *loop, *tmp;
@@ -684,77 +745,341 @@ static void handle_signal(struct udev *udev, int signo)
 				if (worker->pid != pid)
 					continue;
 
-				/* fail event, if worker died unexpectedly */
-				if (worker->event != NULL) {
-					int exitcode;
-
-					if (WIFEXITED(status))
-						exitcode = WEXITSTATUS(status);
-					else if (WIFSIGNALED(status))
-						exitcode = WTERMSIG(status) + 128;
-					else
-						exitcode = 0;
-					worker->event->exitcode = exitcode;
-					err(udev, "worker [%u] unexpectedly returned with %i\n", pid, exitcode);
-					event_queue_delete(worker->event);
+				info(udev, "worker [%u] exit\n", pid);
+				if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+					err(udev, "worker [%u] unexpectedly returned with status 0x%04x\n", pid, status);
+					if (worker->event != NULL) {
+						err(udev, "worker [%u] failed while handling '%s'\n", pid, worker->event->devpath);
+						worker->event->exitcode = -32;
+						event_queue_delete(worker->event);
+						/* drop reference from running event */
+						worker_unref(worker);
+					}
 				}
-
-				udev_list_node_remove(&worker->node);
 				worker_unref(worker);
-				childs--;
-				info(udev, "worker [%u] exit\n", pid);
 				break;
 			}
 		}
 		break;
 	case SIGHUP:
-		reload_config = 1;
+		reload_config = true;
 		break;
 	}
 }
 
-static void startup_log(struct udev *udev)
+static void static_dev_create_from_modules(struct udev *udev)
 {
+	struct utsname kernel;
+	char modules[UTIL_PATH_SIZE];
+	char buf[4096];
 	FILE *f;
-	char path[UTIL_PATH_SIZE];
-	struct stat statbuf;
 
-	f = fopen("/dev/kmsg", "w");
-	if (f != NULL)
-		fprintf(f, "<6>udev: starting version " VERSION "\n");
-
-	util_strscpyl(path, sizeof(path), udev_get_sys_path(udev), "/class/mem/null", NULL);
-	if (lstat(path, &statbuf) == 0 && S_ISDIR(statbuf.st_mode)) {
-		const char *depr_str =
-			"udev: missing sysfs features; please update the kernel "
-			"or disable the kernel's CONFIG_SYSFS_DEPRECATED option; "
-			"udev may fail to work correctly";
-
-		if (f != NULL)
-			fprintf(f, "<3>%s\n", depr_str);
-		err(udev, "%s\n", depr_str);
-		sleep(3);
+	uname(&kernel);
+	util_strscpyl(modules, sizeof(modules), "/lib/modules/", kernel.release, "/modules.devname", NULL);
+	f = fopen(modules, "r");
+	if (f == NULL)
+		return;
+
+	while (fgets(buf, sizeof(buf), f) != NULL) {
+		char *s;
+		const char *modname;
+		const char *devname;
+		const char *devno;
+		int maj, min;
+		char type;
+		mode_t mode;
+		char filename[UTIL_PATH_SIZE];
+
+		if (buf[0] == '#')
+			continue;
+
+		modname = buf;
+		s = strchr(modname, ' ');
+		if (s == NULL)
+			continue;
+		s[0] = '\0';
+
+		devname = &s[1];
+		s = strchr(devname, ' ');
+		if (s == NULL)
+			continue;
+		s[0] = '\0';
+
+		devno = &s[1];
+		s = strchr(devno, ' ');
+		if (s == NULL)
+			s = strchr(devno, '\n');
+		if (s != NULL)
+			s[0] = '\0';
+		if (sscanf(devno, "%c%u:%u", &type, &maj, &min) != 3)
+			continue;
+
+		if (type == 'c')
+			mode = 0600 | S_IFCHR;
+		else if (type == 'b')
+			mode = 0600 | S_IFBLK;
+		else
+			continue;
+
+		util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/", devname, NULL);
+		util_create_path(udev, filename);
+		udev_selinux_setfscreatecon(udev, filename, mode);
+		info(udev, "mknod '%s' %c%u:%u\n", filename, type, maj, min);
+		if (mknod(filename, mode, makedev(maj, min)) < 0 && errno == EEXIST)
+			utimensat(AT_FDCWD, filename, NULL, 0);
+		udev_selinux_resetfscreatecon(udev);
+	}
+
+	fclose(f);
+}
+
+static int copy_dir(struct udev *udev, DIR *dir_from, DIR *dir_to, int maxdepth)
+{
+	struct dirent *dent;
+
+	for (dent = readdir(dir_from); dent != NULL; dent = readdir(dir_from)) {
+		struct stat stats;
+
+		if (dent->d_name[0] == '.')
+			continue;
+		if (fstatat(dirfd(dir_from), dent->d_name, &stats, AT_SYMLINK_NOFOLLOW) != 0)
+			continue;
+
+		if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) {
+			udev_selinux_setfscreateconat(udev, dirfd(dir_to), dent->d_name, stats.st_mode & 0777);
+			if (mknodat(dirfd(dir_to), dent->d_name, stats.st_mode, stats.st_rdev) == 0) {
+				fchmodat(dirfd(dir_to), dent->d_name, stats.st_mode & 0777, 0);
+				fchownat(dirfd(dir_to), dent->d_name, stats.st_uid, stats.st_gid, 0);
+			} else {
+				utimensat(dirfd(dir_to), dent->d_name, NULL, 0);
+			}
+			udev_selinux_resetfscreatecon(udev);
+		} else if (S_ISLNK(stats.st_mode)) {
+			char target[UTIL_PATH_SIZE];
+			ssize_t len;
+
+			len = readlinkat(dirfd(dir_from), dent->d_name, target, sizeof(target));
+			if (len <= 0 || len == (ssize_t)sizeof(target))
+				continue;
+			target[len] = '\0';
+			udev_selinux_setfscreateconat(udev, dirfd(dir_to), dent->d_name, S_IFLNK);
+			if (symlinkat(target, dirfd(dir_to), dent->d_name) < 0 && errno == EEXIST)
+				utimensat(dirfd(dir_to), dent->d_name, NULL, AT_SYMLINK_NOFOLLOW);
+			udev_selinux_resetfscreatecon(udev);
+		} else if (S_ISDIR(stats.st_mode)) {
+			DIR *dir2_from, *dir2_to;
+
+			if (maxdepth == 0)
+				continue;
+
+			udev_selinux_setfscreateconat(udev, dirfd(dir_to), dent->d_name, S_IFDIR|0755);
+			mkdirat(dirfd(dir_to), dent->d_name, 0755);
+			udev_selinux_resetfscreatecon(udev);
+
+			dir2_to = fdopendir(openat(dirfd(dir_to), dent->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC));
+			if (dir2_to == NULL)
+				continue;
+
+			dir2_from = fdopendir(openat(dirfd(dir_from), dent->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC));
+			if (dir2_from == NULL) {
+				closedir(dir2_to);
+				continue;
+			}
+
+			copy_dir(udev, dir2_from, dir2_to, maxdepth-1);
+
+			closedir(dir2_to);
+			closedir(dir2_from);
+		}
+	}
+
+	return 0;
+}
+
+static void static_dev_create_links(struct udev *udev, DIR *dir)
+{
+	struct stdlinks {
+		const char *link;
+		const char *target;
+	};
+	static const struct stdlinks stdlinks[] = {
+		{ "core", "/proc/kcore" },
+		{ "fd", "/proc/self/fd" },
+		{ "stdin", "/proc/self/fd/0" },
+		{ "stdout", "/proc/self/fd/1" },
+		{ "stderr", "/proc/self/fd/2" },
+	};
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(stdlinks); i++) {
+		struct stat sb;
+
+		if (stat(stdlinks[i].target, &sb) == 0) {
+			udev_selinux_setfscreateconat(udev, dirfd(dir), stdlinks[i].link, S_IFLNK);
+			if (symlinkat(stdlinks[i].target, dirfd(dir), stdlinks[i].link) < 0 && errno == EEXIST)
+				utimensat(dirfd(dir), stdlinks[i].link, NULL, AT_SYMLINK_NOFOLLOW);
+			udev_selinux_resetfscreatecon(udev);
+		}
+	}
+}
+
+static void static_dev_create_from_devices(struct udev *udev, DIR *dir)
+{
+	DIR *dir_from;
+
+	dir_from = opendir(LIBEXECDIR "/devices");
+	if (dir_from == NULL)
+		return;
+	copy_dir(udev, dir_from, dir, 8);
+	closedir(dir_from);
+}
+
+static void static_dev_create(struct udev *udev)
+{
+	DIR *dir;
+
+	dir = opendir(udev_get_dev_path(udev));
+	if (dir == NULL)
+		return;
+
+	static_dev_create_links(udev, dir);
+	static_dev_create_from_devices(udev, dir);
+
+	closedir(dir);
+}
+
+static int mem_size_mb(void)
+{
+	FILE *f;
+	char buf[4096];
+	long int memsize = -1;
+
+	f = fopen("/proc/meminfo", "r");
+	if (f == NULL)
+		return -1;
+
+	while (fgets(buf, sizeof(buf), f) != NULL) {
+		long int value;
+
+		if (sscanf(buf, "MemTotal: %ld kB", &value) == 1) {
+			memsize = value / 1024;
+			break;
+		}
 	}
 
-	if (f != NULL)
+	fclose(f);
+	return memsize;
+}
+
+static int convert_db(struct udev *udev)
+{
+	char filename[UTIL_PATH_SIZE];
+	FILE *f;
+	struct udev_enumerate *udev_enumerate;
+	struct udev_list_entry *list_entry;
+
+	/* current database */
+	util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.run/udev/db3", NULL);
+	if (access(filename, F_OK) >= 0)
+		return 0;
+
+	/* make sure we do not get here again */
+	util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.run/udev/db3/", NULL);
+	util_create_path(udev, filename);
+
+	/* old database */
+	util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/db", NULL);
+	if (access(filename, F_OK) < 0)
+		return 0;
+
+	f = fopen("/dev/kmsg", "w");
+	if (f != NULL) {
+		fprintf(f, "<6>udev[%u]: converting old udev database\n", getpid());
 		fclose(f);
+	}
+
+	udev_enumerate = udev_enumerate_new(udev);
+	if (udev_enumerate == NULL)
+		return -1;
+	udev_enumerate_scan_devices(udev_enumerate);
+	udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(udev_enumerate)) {
+		struct udev_device *device;
+
+		device = udev_device_new_from_syspath(udev, udev_list_entry_get_name(list_entry));
+		if (device == NULL)
+			continue;
+
+		/* try to find the old database for devices without a current one */
+		if (udev_device_read_db(device, NULL) < 0) {
+			bool have_db;
+			const char *id;
+			struct stat stats;
+			char devpath[UTIL_PATH_SIZE];
+			char from[UTIL_PATH_SIZE];
+
+			have_db = false;
+
+			/* find database in old location */
+			id = udev_device_get_id_filename(device);
+			util_strscpyl(from, sizeof(from), udev_get_dev_path(udev), "/.udev/db/", id, NULL);
+			if (lstat(from, &stats) == 0) {
+				if (!have_db) {
+					udev_device_read_db(device, from);
+					have_db = true;
+				}
+				unlink(from);
+			}
+
+			/* find old database with $subsys:$sysname name */
+			util_strscpyl(from, sizeof(from), udev_get_dev_path(udev),
+				     "/.udev/db/", udev_device_get_subsystem(device), ":",
+				     udev_device_get_sysname(device), NULL);
+			if (lstat(from, &stats) == 0) {
+				if (!have_db) {
+					udev_device_read_db(device, from);
+					have_db = true;
+				}
+				unlink(from);
+			}
+
+			/* find old database with the encoded devpath name */
+			util_path_encode(udev_device_get_devpath(device), devpath, sizeof(devpath));
+			util_strscpyl(from, sizeof(from), udev_get_dev_path(udev),
+				      "/.udev/db/", devpath, NULL);
+			if (lstat(from, &stats) == 0) {
+				if (!have_db) {
+					udev_device_read_db(device, from);
+					have_db = true;
+				}
+				unlink(from);
+			}
+
+			/* write out new database */
+			if (have_db)
+				udev_device_update_db(device);
+		}
+		udev_device_unref(device);
+	}
+	udev_enumerate_unref(udev_enumerate);
+	return 0;
 }
 
 int main(int argc, char *argv[])
 {
 	struct udev *udev;
 	int fd;
+	FILE *f;
 	sigset_t mask;
-	const char *value;
-	int daemonize = 0;
+	int daemonize = false;
 	int resolve_names = 1;
 	static const struct option options[] = {
 		{ "daemon", no_argument, NULL, 'd' },
-		{ "debug-trace", no_argument, NULL, 't' },
 		{ "debug", no_argument, NULL, 'D' },
+		{ "children-max", required_argument, NULL, 'c' },
+		{ "exec-delay", required_argument, NULL, 'e' },
+		{ "resolve-names", required_argument, NULL, 'N' },
 		{ "help", no_argument, NULL, 'h' },
 		{ "version", no_argument, NULL, 'V' },
-		{ "resolve-names", required_argument, NULL, 'N' },
 		{}
 	};
 	int rc = 1;
@@ -768,22 +1093,25 @@ int main(int argc, char *argv[])
 	info(udev, "version %s\n", VERSION);
 	udev_selinux_init(udev);
 
-	while (1) {
+	for (;;) {
 		int option;
 
-		option = getopt_long(argc, argv, "dDthV", options, NULL);
+		option = getopt_long(argc, argv, "c:deDthV", options, NULL);
 		if (option == -1)
 			break;
 
 		switch (option) {
 		case 'd':
-			daemonize = 1;
+			daemonize = true;
+			break;
+		case 'c':
+			children_max = strtoul(optarg, NULL, 0);
 			break;
-		case 't':
-			debug_trace = 1;
+		case 'e':
+			exec_delay = strtoul(optarg, NULL, 0);
 			break;
 		case 'D':
-			debug = 1;
+			debug = true;
 			if (udev_get_log_priority(udev) < LOG_INFO)
 				udev_set_log_priority(udev, LOG_INFO);
 			break;
@@ -801,8 +1129,15 @@ int main(int argc, char *argv[])
 			}
 			break;
 		case 'h':
-			printf("Usage: udevd [--help] [--daemon] [--debug-trace] [--debug] "
-			       "[--resolve-names=early|late|never] [--version]\n");
+			printf("Usage: udevd OPTIONS\n"
+			       "  --daemon\n"
+			       "  --debug\n"
+			       "  --children-max=<maximum number of workers>\n"
+			       "  --exec-delay=<seconds to wait before executing RUN=>\n"
+			       "  --resolve-names=early|late|never\n" 
+			       "  --version\n"
+			       "  --help\n"
+			       "\n");
 			goto exit;
 		case 'V':
 			printf("%s\n", VERSION);
@@ -812,13 +1147,55 @@ int main(int argc, char *argv[])
 		}
 	}
 
+	/*
+	 * read the kernel commandline, in case we need to get into debug mode
+	 *   udev.log-priority=<level>              syslog priority
+	 *   udev.children-max=<number of workers>  events are fully serialized if set to 1
+	 *
+	 */
+	f = fopen("/proc/cmdline", "r");
+	if (f != NULL) {
+		char cmdline[4096];
+
+		if (fgets(cmdline, sizeof(cmdline), f) != NULL) {
+			char *pos;
+
+			pos = strstr(cmdline, "udev.log-priority=");
+			if (pos != NULL) {
+				pos += strlen("udev.log-priority=");
+				udev_set_log_priority(udev, util_log_priority(pos));
+			}
+
+			pos = strstr(cmdline, "udev.children-max=");
+			if (pos != NULL) {
+				pos += strlen("udev.children-max=");
+				children_max = strtoul(pos, NULL, 0);
+			}
+
+			pos = strstr(cmdline, "udev.exec-delay=");
+			if (pos != NULL) {
+				pos += strlen("udev.exec-delay=");
+				exec_delay = strtoul(pos, NULL, 0);
+			}
+		}
+		fclose(f);
+	}
+
 	if (getuid() != 0) {
 		fprintf(stderr, "root privileges required\n");
 		err(udev, "root privileges required\n");
 		goto exit;
 	}
 
-	/* make sure std{in,out,err} fd's are in a sane state */
+	/* set umask before creating any file/directory */
+	chdir("/");
+	umask(022);
+
+	/* create standard links, copy static nodes, create nodes from modules */
+	static_dev_create(udev);
+	static_dev_create_from_modules(udev);
+
+	/* before opening new files, make sure std{in,out,err} fds are in a sane state */
 	fd = open("/dev/null", O_RDWR);
 	if (fd < 0) {
 		fprintf(stderr, "cannot open /dev/null\n");
@@ -829,7 +1206,6 @@ int main(int argc, char *argv[])
 	if (write(STDERR_FILENO, 0, 0) < 0)
 		dup2(fd, STDERR_FILENO);
 
-	/* init control socket, bind() ensures, that only one udevd instance is running */
 	udev_ctrl = udev_ctrl_new_from_socket(udev, UDEV_CTRL_SOCK_PATH);
 	if (udev_ctrl == NULL) {
 		fprintf(stderr, "error initializing control socket");
@@ -865,25 +1241,32 @@ int main(int argc, char *argv[])
 
 	if (udev_get_rules_path(udev) != NULL) {
 		inotify_add_watch(pfd[FD_INOTIFY].fd, udev_get_rules_path(udev),
-				  IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
+				  IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 	} else {
 		char filename[UTIL_PATH_SIZE];
+		struct stat statbuf;
 
-		inotify_add_watch(pfd[FD_INOTIFY].fd, UDEV_PREFIX "/lib/udev/rules.d",
-				  IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
+		inotify_add_watch(pfd[FD_INOTIFY].fd, LIBEXECDIR "/rules.d",
+				  IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 		inotify_add_watch(pfd[FD_INOTIFY].fd, SYSCONFDIR "/udev/rules.d",
-				  IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
+				  IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 
 		/* watch dynamic rules directory */
-		util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/rules.d", NULL);
+		util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.run/udev/rules.d", NULL);
+		if (stat(filename, &statbuf) != 0) {
+			util_create_path(udev, filename);
+			udev_selinux_setfscreatecon(udev, filename, S_IFDIR|0755);
+			mkdir(filename, 0755);
+			udev_selinux_resetfscreatecon(udev);
+		}
 		inotify_add_watch(pfd[FD_INOTIFY].fd, filename,
-				  IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
+				  IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 	}
 	udev_watch_restore(udev);
 
 	/* block and listen to all signals on signalfd */
 	sigfillset(&mask);
-	sigprocmask(SIG_SETMASK, &mask, NULL);
+	sigprocmask(SIG_SETMASK, &mask, &orig_sigmask);
 	pfd[FD_SIGNAL].fd = signalfd(-1, &mask, 0);
 	if (pfd[FD_SIGNAL].fd < 0) {
 		fprintf(stderr, "error getting signalfd\n");
@@ -893,14 +1276,13 @@ int main(int argc, char *argv[])
 	}
 
 	/* unnamed socket from workers to the main daemon */
-	if (socketpair(AF_LOCAL, SOCK_DGRAM, 0, worker_watch) < 0) {
+	if (socketpair(AF_LOCAL, SOCK_DGRAM|SOCK_CLOEXEC, 0, worker_watch) < 0) {
 		fprintf(stderr, "error getting socketpair\n");
 		err(udev, "error getting socketpair\n");
 		rc = 6;
 		goto exit;
 	}
 	pfd[FD_WORKER].fd = worker_watch[READ_END];
-	util_set_fd_cloexec(worker_watch[WRITE_END]);
 
 	rules = udev_rules_new(udev, resolve_names);
 	if (rules == NULL) {
@@ -914,6 +1296,17 @@ int main(int argc, char *argv[])
 		goto exit;
 	}
 
+	/* if needed, convert old database from earlier udev version */
+	convert_db(udev);
+
+	if (!debug) {
+		dup2(fd, STDIN_FILENO);
+		dup2(fd, STDOUT_FILENO);
+		dup2(fd, STDERR_FILENO);
+	}
+	if (fd > STDERR_FILENO)
+		close(fd);
+
 	if (daemonize) {
 		pid_t pid;
 
@@ -929,52 +1322,49 @@ int main(int argc, char *argv[])
 			rc = 0;
 			goto exit;
 		}
+	} else {
+		sd_notify(1, "READY=1");
 	}
 
-	startup_log(udev);
-
-	/* redirect std{out,err} */
-	if (!debug && !debug_trace) {
-		dup2(fd, STDIN_FILENO);
-		dup2(fd, STDOUT_FILENO);
-		dup2(fd, STDERR_FILENO);
-	}
-	if (fd > STDERR_FILENO)
-		close(fd);
-
-	/* set scheduling priority for the daemon */
+	/* set scheduling priority for the main daemon process */
 	setpriority(PRIO_PROCESS, 0, UDEVD_PRIORITY);
 
-	chdir("/");
-	umask(022);
 	setsid();
 
-	/* OOM_DISABLE == -17 */
-	fd = open("/proc/self/oom_adj", O_RDWR);
+	f = fopen("/dev/kmsg", "w");
+	if (f != NULL) {
+		fprintf(f, "<6>udev[%u]: starting version " VERSION "\n", getpid());
+		fclose(f);
+	}
+
+	fd = open("/proc/self/oom_score_adj", O_RDWR);
 	if (fd < 0) {
-		err(udev, "error disabling OOM: %m\n");
+		/* Fallback to old interface */
+		fd = open("/proc/self/oom_adj", O_RDWR);
+		if (fd < 0) {
+			err(udev, "error disabling OOM: %m\n");
+		} else {
+			/* OOM_DISABLE == -17 */
+			write(fd, "-17", 3);
+			close(fd);
+		}
 	} else {
-		write(fd, "-17", 3);
+		write(fd, "-1000", 5);
 		close(fd);
 	}
 
-	/* in trace mode run one event after the other */
-	if (debug_trace) {
-		max_childs = 1;
-	} else {
+	if (children_max <= 0) {
 		int memsize = mem_size_mb();
 
+		/* set value depending on the amount of RAM */
 		if (memsize > 0)
-			max_childs = 128 + (memsize / 8);
+			children_max = 128 + (memsize / 8);
 		else
-			max_childs = 128;
+			children_max = 128;
 	}
+	info(udev, "set children_max to %u\n", children_max);
 
-	/* possibly overwrite maximum limit of executed events */
-	value = getenv("UDEVD_MAX_CHILDS");
-	if (value)
-		max_childs = strtoul(value, NULL, 10);
-	info(udev, "initialize max_childs to %u\n", max_childs);
+	udev_rules_apply_static_dev_perms(rules);
 
 	udev_list_init(&event_list);
 	udev_list_init(&worker_list);
@@ -984,7 +1374,7 @@ int main(int argc, char *argv[])
 		int timeout;
 
 		/* set timeout to kill idle workers */
-		if (udev_list_is_empty(&event_list) && childs > 2)
+		if (udev_list_is_empty(&event_list) && children > 2)
 			timeout = 3 * 1000;
 		else
 			timeout = -1;
@@ -995,7 +1385,7 @@ int main(int argc, char *argv[])
 
 		/* timeout - kill idle workers */
 		if (fdcount == 0)
-			worker_kill(2);
+			worker_kill(udev, 2);
 
 		/* event has finished */
 		if (pfd[FD_WORKER].revents & POLLIN)
@@ -1007,9 +1397,8 @@ int main(int argc, char *argv[])
 
 			dev = udev_monitor_receive_device(monitor);
 			if (dev != NULL)
-				event_queue_insert(dev);
-			else
-				udev_device_unref(dev);
+				if (event_queue_insert(dev) < 0)
+					udev_device_unref(dev);
 		}
 
 		/* start new events */
@@ -1044,7 +1433,7 @@ int main(int argc, char *argv[])
 		if (reload_config) {
 			struct udev_rules *rules_new;
 
-			worker_kill(0);
+			worker_kill(udev, 0);
 			rules_new = udev_rules_new(udev, resolve_names);
 			if (rules_new != NULL) {
 				udev_rules_unref(rules);