X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Fudevd.c;h=d227a71fd1f5bc742229275ecb576cc723bae5df;hp=0c82e56dc5291b9b9d4502715afdf2546e9c5982;hb=e9a77fd828e9d415e4d64dd74aa780a61f726536;hpb=cb25a9585d87d8dd13d9eae66fd232e3dfdc8fac

diff --git a/udev/udevd.c b/udev/udevd.c
index 0c82e56dc..d227a71fd 100644
--- a/udev/udevd.c
+++ b/udev/udevd.c
@@ -27,7 +27,9 @@
 #include <fcntl.h>
 #include <time.h>
 #include <getopt.h>
+#include <dirent.h>
 #include <sys/select.h>
+#include <sys/poll.h>
 #include <sys/wait.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
@@ -36,7 +38,6 @@
 #endif
 
 #include "udev.h"
-#include "udev-rules.h"
 
 #define UDEVD_PRIORITY			-4
 #define UDEV_PRIORITY			-2
@@ -59,21 +60,19 @@ static void log_fn(struct udev *udev, int priority,
 }
 
 static int debug_trace;
-static struct udev_rules rules;
+static struct udev_rules *rules;
 static struct udev_ctrl *udev_ctrl;
 static struct udev_monitor *kernel_monitor;
 static int inotify_fd = -1;
-
-static int signal_pipe[2] = {-1, -1};
 static volatile int sigchilds_waiting;
 static volatile int udev_exit;
 static volatile int reload_config;
+static volatile int signal_received;
 static int run_exec_q;
 static int stop_exec_q;
 static int max_childs;
-
-static LIST_HEAD(exec_list);
-static LIST_HEAD(running_list);
+static int childs;
+static struct udev_list_node event_list;
 
 enum event_state {
 	EVENT_QUEUED,
@@ -81,6 +80,15 @@ enum event_state {
 	EVENT_FAILED,
 };
 
+static struct udev_event *node_to_event(struct udev_list_node *node)
+{
+	char *event;
+
+	event = (char *)node;
+	event -= offsetof(struct udev_event, node);
+	return (struct udev_event *)event;
+}
+
 static void export_event_state(struct udev_event *event, enum event_state state)
 {
 	char filename[UTIL_PATH_SIZE];
@@ -100,9 +108,9 @@ static void export_event_state(struct udev_event *event, enum event_state state)
 
 	switch (state) {
 	case EVENT_QUEUED:
-		unlink(filename_failed);
-		delete_path(event->udev, filename_failed);
-		create_path(event->udev, filename);
+		if(unlink(filename_failed) == 0)
+			util_delete_path(event->udev, filename_failed);
+		util_create_path(event->udev, filename);
 		udev_selinux_setfscreatecon(event->udev, filename, S_IFLNK);
 		symlink(udev_device_get_devpath(event->dev), filename);
 		udev_selinux_resetfscreatecon(event->udev);
@@ -122,20 +130,24 @@ static void export_event_state(struct udev_event *event, enum event_state state)
 				info(event->udev, "renamed devpath, moved failed state of '%s' to %s'\n",
 				     udev_device_get_devpath_old(event->dev), udev_device_get_devpath(event->dev));
 		} else {
-			unlink(filename_failed);
-			delete_path(event->udev, filename_failed);
+			if (unlink(filename_failed) == 0)
+				util_delete_path(event->udev, filename_failed);
 		}
 
 		unlink(filename);
-		delete_path(event->udev, filename);
+
+		/* clean up possibly empty queue directory */
+		if (udev_list_is_empty(&event_list))
+			util_delete_path(event->udev, filename);
 		break;
 	case EVENT_FAILED:
 		/* move failed event to the failed directory */
-		create_path(event->udev, filename_failed);
+		util_create_path(event->udev, filename_failed);
 		rename(filename, filename_failed);
 
 		/* clean up possibly empty queue directory */
-		delete_path(event->udev, filename);
+		if (udev_list_is_empty(&event_list))
+			util_delete_path(event->udev, filename);
 		break;
 	}
 
@@ -144,7 +156,7 @@ static void export_event_state(struct udev_event *event, enum event_state state)
 
 static void event_queue_delete(struct udev_event *event)
 {
-	list_del(&event->node);
+	udev_list_node_remove(&event->node);
 
 	/* mark as failed, if "add" event returns non-zero */
 	if (event->exitstatus && strcmp(udev_device_get_action(event->dev), "add") == 0)
@@ -168,6 +180,13 @@ static void event_fork(struct udev_event *event)
 	struct sigaction act;
 	int err;
 
+	if (debug_trace) {
+		event->trace = 1;
+		fprintf(stderr, "fork %s (%llu)\n",
+		       udev_device_get_syspath(event->dev),
+		       udev_device_get_seqnum(event->dev));
+	}
+
 	pid = fork();
 	switch (pid) {
 	case 0:
@@ -176,8 +195,6 @@ static void event_fork(struct udev_event *event)
 		udev_ctrl_unref(udev_ctrl);
 		if (inotify_fd >= 0)
 			close(inotify_fd);
-		close(signal_pipe[READ_END]);
-		close(signal_pipe[WRITE_END]);
 		logging_close();
 		logging_init("udevd-event");
 		setpriority(PRIO_PROCESS, 0, UDEV_PRIORITY);
@@ -200,7 +217,7 @@ static void event_fork(struct udev_event *event)
 		alarm(UDEV_EVENT_TIMEOUT);
 
 		/* apply rules, create node, symlinks */
-		err = udev_event_run(event, &rules);
+		err = udev_event_execute_rules(event, rules);
 
 		/* rules may change/disable the timeout */
 		if (udev_device_get_event_timeout(event->dev) >= 0)
@@ -208,7 +225,8 @@ static void event_fork(struct udev_event *event)
 
 		/* execute RUN= */
 		if (err == 0 && !event->ignore_device && udev_get_run(event->udev))
-			udev_rules_run(event);
+			udev_event_execute_run(event);
+
 		info(event->udev, "seq %llu exit with %i\n", udev_device_get_seqnum(event->dev), err);
 		logging_close();
 		if (err != 0)
@@ -227,6 +245,7 @@ static void event_fork(struct udev_event *event)
 		     udev_device_get_subsystem(event->dev),
 		     time(NULL) - event->queue_time);
 		event->pid = pid;
+		childs++;
 	}
 }
 
@@ -253,24 +272,15 @@ static void event_queue_insert(struct udev_event *event)
 		close(fd);
 	}
 
-	/* run one event after the other in debug mode */
-	if (debug_trace) {
-		list_add_tail(&event->node, &running_list);
-		event_fork(event);
-		waitpid(event->pid, NULL, 0);
-		event_queue_delete(event);
-		return;
-	}
+
+	udev_list_node_append(&event->node, &event_list);
+	run_exec_q = 1;
 
 	/* run all events with a timeout set immediately */
 	if (udev_device_get_timeout(event->dev) > 0) {
-		list_add_tail(&event->node, &running_list);
 		event_fork(event);
 		return;
 	}
-
-	list_add_tail(&event->node, &exec_list);
-	run_exec_q = 1;
 }
 
 static int mem_size_mb(void)
@@ -298,45 +308,56 @@ static int mem_size_mb(void)
 
 static int compare_devpath(const char *running, const char *waiting)
 {
-	int i;
+	int i = 0;
 
-	for (i = 0; i < UTIL_PATH_SIZE; i++) {
-		/* identical device event found */
-		if (running[i] == '\0' && waiting[i] == '\0')
-			return 1;
+	while (running[i] != '\0' && running[i] == waiting[i])
+		i++;
 
-		/* parent device event found */
-		if (running[i] == '\0' && waiting[i] == '/')
-			return 2;
+	/* identical device event found */
+	if (running[i] == '\0' && waiting[i] == '\0')
+		return 1;
 
-		/* child device event found */
-		if (running[i] == '/' && waiting[i] == '\0')
-			return 3;
+	/* parent device event found */
+	if (running[i] == '\0' && waiting[i] == '/')
+		return 2;
 
-		/* no matching event */
-		if (running[i] != waiting[i])
-			break;
-	}
+	/* child device event found */
+	if (running[i] == '/' && waiting[i] == '\0')
+		return 3;
 
+	/* no matching event */
 	return 0;
 }
 
 /* lookup event for identical, parent, child, or physical device */
-static int devpath_busy(struct udev_event *event, int limit)
+static int devpath_busy(struct udev_event *event)
 {
-	struct udev_event *loop_event;
-	int childs_count = 0;
+	struct udev_list_node *loop;
 
-	/* check exec-queue which may still contain delayed events we depend on */
-	list_for_each_entry(loop_event, &exec_list, node) {
-		/* skip ourself and all later events */
+	if (event->delaying_seqnum > 0) {
+	}
+	/* check if queue contains events we depend on */
+	udev_list_node_foreach(loop, &event_list) {
+		struct udev_event *loop_event = node_to_event(loop);
+
+		/* we already found a later event, earlier can not block us, no need to check again */
+		if (udev_device_get_seqnum(loop_event->dev) < event->delaying_seqnum)
+			continue;
+
+		/* event we checked earlier still exists, no need to check again */
+		if (udev_device_get_seqnum(loop_event->dev) == event->delaying_seqnum)
+			return 2;
+
+		/* found ourself, no later event can block us */
 		if (udev_device_get_seqnum(loop_event->dev) >= udev_device_get_seqnum(event->dev))
 			break;
 
 		/* check our old name */
 		if (udev_device_get_devpath_old(event->dev) != NULL)
-			if (strcmp(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath_old(event->dev)) == 0)
-				return 2;
+			if (strcmp(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath_old(event->dev)) == 0) {
+				event->delaying_seqnum = udev_device_get_seqnum(loop_event->dev);
+				return 3;
+			}
 
 		/* check identical, parent, or child device event */
 		if (compare_devpath(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath(event->dev)) != 0) {
@@ -344,57 +365,10 @@ static int devpath_busy(struct udev_event *event, int limit)
 			    udev_device_get_seqnum(event->dev),
 			    udev_device_get_seqnum(loop_event->dev),
 			    udev_device_get_devpath(loop_event->dev));
-			return 3;
-		}
-
-		/* check for our major:minor number */
-		if (major(udev_device_get_devnum(event->dev)) > 0 &&
-		    udev_device_get_devnum(loop_event->dev) == udev_device_get_devnum(event->dev) &&
-		    strcmp(udev_device_get_subsystem(event->dev), udev_device_get_subsystem(loop_event->dev)) == 0) {
-			dbg(event->udev, "%llu, device event still pending %llu (%d:%d)\n",
-			    udev_device_get_seqnum(event->dev),
-			    udev_device_get_seqnum(loop_event->dev),
-			    major(udev_device_get_devnum(loop_event->dev)), minor(udev_device_get_devnum(loop_event->dev)));
+			event->delaying_seqnum = udev_device_get_seqnum(loop_event->dev);
 			return 4;
 		}
 
-		/* check physical device event (special case of parent) */
-		if (udev_device_get_physdevpath(event->dev) != NULL &&
-		    strcmp(udev_device_get_action(event->dev), "add") == 0)
-			if (compare_devpath(udev_device_get_devpath(loop_event->dev),
-					    udev_device_get_physdevpath(event->dev)) != 0) {
-				dbg(event->udev, "%llu, physical device event still pending %llu (%s)\n",
-				    udev_device_get_seqnum(event->dev),
-				    udev_device_get_seqnum(loop_event->dev),
-				    udev_device_get_devpath(loop_event->dev));
-				return 5;
-			}
-	}
-
-	/* check run queue for still running events */
-	list_for_each_entry(loop_event, &running_list, node) {
-		childs_count++;
-
-		if (childs_count++ >= limit) {
-			info(event->udev, "%llu, maximum number (%i) of childs reached\n",
-			     udev_device_get_seqnum(event->dev), childs_count);
-			return 1;
-		}
-
-		/* check our old name */
-		if (udev_device_get_devpath_old(event->dev) != NULL)
-			if (strcmp(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath_old(event->dev)) == 0)
-				return 2;
-
-		/* check identical, parent, or child device event */
-		if (compare_devpath(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath(event->dev)) != 0) {
-			dbg(event->udev, "%llu, device event still running %llu (%s)\n",
-			    udev_device_get_seqnum(event->dev),
-			    udev_device_get_seqnum(loop_event->dev),
-			    udev_device_get_devpath(loop_event->dev));
-			return 3;
-		}
-
 		/* check for our major:minor number */
 		if (major(udev_device_get_devnum(event->dev)) > 0 &&
 		    udev_device_get_devnum(loop_event->dev) == udev_device_get_devnum(event->dev) &&
@@ -403,7 +377,8 @@ static int devpath_busy(struct udev_event *event, int limit)
 			    udev_device_get_seqnum(event->dev),
 			    udev_device_get_seqnum(loop_event->dev),
 			    major(udev_device_get_devnum(loop_event->dev)), minor(udev_device_get_devnum(loop_event->dev)));
-			return 4;
+			event->delaying_seqnum = udev_device_get_seqnum(loop_event->dev);
+			return 5;
 		}
 
 		/* check physical device event (special case of parent) */
@@ -415,7 +390,8 @@ static int devpath_busy(struct udev_event *event, int limit)
 				    udev_device_get_seqnum(event->dev),
 				    udev_device_get_seqnum(loop_event->dev),
 				    udev_device_get_devpath(loop_event->dev));
-				return 5;
+				event->delaying_seqnum = udev_device_get_seqnum(loop_event->dev);
+				return 6;
 			}
 	}
 	return 0;
@@ -424,23 +400,36 @@ static int devpath_busy(struct udev_event *event, int limit)
 /* serializes events for the identical and parent and child devices */
 static void event_queue_manager(struct udev *udev)
 {
-	struct udev_event *loop_event;
-	struct udev_event *tmp_event;
+	struct udev_list_node *loop;
+	struct udev_list_node *tmp;
 
-	if (list_empty(&exec_list))
+	if (udev_list_is_empty(&event_list)) {
+		if (childs > 0) {
+			err(udev, "event list empty, but childs count is %i", childs);
+			childs = 0;
+		}
 		return;
+	}
+
+	udev_list_node_foreach_safe(loop, tmp, &event_list) {
+		struct udev_event *loop_event = node_to_event(loop);
+
+		if (childs >= max_childs) {
+			info(udev, "maximum number (%i) of childs reached\n", childs);
+			break;
+		}
+
+		if (loop_event->pid != 0)
+			continue;
 
-	list_for_each_entry_safe(loop_event, tmp_event, &exec_list, node) {
-		/* serialize and wait for parent or child events */
-		if (devpath_busy(loop_event, max_childs) != 0) {
+		/* do not start event if parent or child event is still running */
+		if (devpath_busy(loop_event) != 0) {
 			dbg(udev, "delay seq %llu (%s)\n",
 			    udev_device_get_seqnum(loop_event->dev),
 			    udev_device_get_devpath(loop_event->dev));
 			continue;
 		}
 
-		/* move event to run list */
-		list_move_tail(&loop_event->node, &running_list);
 		event_fork(loop_event);
 		dbg(udev, "moved seq %llu to running list\n", udev_device_get_seqnum(loop_event->dev));
 	}
@@ -511,7 +500,6 @@ static void handle_ctrl_msg(struct udev_ctrl *uctrl)
 		info(udev, "udevd message (SET_MAX_CHILDS) received, max_childs=%i\n", i);
 		max_childs = i;
 	}
-
 	udev_ctrl_msg_unref(ctrl_msg);
 }
 
@@ -531,24 +519,30 @@ static void asmlinkage sig_handler(int signum)
 			break;
 	}
 
-	/* write to pipe, which will wakeup select() in our mainloop */
-	write(signal_pipe[WRITE_END], "", 1);
+	signal_received = 1;
 }
 
 static void udev_done(int pid, int exitstatus)
 {
-	/* find event associated with pid and delete it */
-	struct udev_event *event;
-
-	list_for_each_entry(event, &running_list, node) {
-		if (event->pid == pid) {
-			info(event->udev, "seq %llu cleanup, pid [%d], status %i, %ld seconds old\n",
-			     udev_device_get_seqnum(event->dev), event->pid,
-			     exitstatus, time(NULL) - event->queue_time);
-			event->exitstatus = exitstatus;
-			event_queue_delete(event);
+	struct udev_list_node *loop;
 
-			/* there may be events waiting with the same devpath */
+	/* find event associated with pid and delete it */
+	udev_list_node_foreach(loop, &event_list) {
+		struct udev_event *loop_event = node_to_event(loop);
+
+		if (loop_event->pid == pid) {
+			info(loop_event->udev, "seq %llu cleanup, pid [%d], status %i, %ld seconds old\n",
+			     udev_device_get_seqnum(loop_event->dev), loop_event->pid,
+			     exitstatus, time(NULL) - loop_event->queue_time);
+			loop_event->exitstatus = exitstatus;
+			if (debug_trace)
+				fprintf(stderr, "exit %s (%llu)\n",
+				       udev_device_get_syspath(loop_event->dev),
+				       udev_device_get_seqnum(loop_event->dev));
+			event_queue_delete(loop_event);
+			childs--;
+
+			/* there may be dependent events waiting */
 			run_exec_q = 1;
 			return;
 		}
@@ -574,6 +568,38 @@ static void reap_sigchilds(void)
 	}
 }
 
+static void cleanup_queue_dir(struct udev *udev)
+{
+	char dirname[UTIL_PATH_SIZE];
+	char filename[UTIL_PATH_SIZE];
+	DIR *dir;
+
+	util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
+	util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
+	unlink(filename);
+
+	util_strlcpy(dirname, udev_get_dev_path(udev), sizeof(dirname));
+	util_strlcat(dirname, "/.udev/queue", sizeof(dirname));
+	dir = opendir(dirname);
+	if (dir != NULL) {
+		while (1) {
+			struct dirent *dent;
+
+			dent = readdir(dir);
+			if (dent == NULL || dent->d_name[0] == '\0')
+				break;
+			if (dent->d_name[0] == '.')
+				continue;
+			util_strlcpy(filename, dirname, sizeof(filename));
+			util_strlcat(filename, "/", sizeof(filename));
+			util_strlcat(filename, dent->d_name, sizeof(filename));
+			unlink(filename);
+		}
+		closedir(dir);
+		rmdir(dirname);
+	}
+}
+
 static void export_initial_seqnum(struct udev *udev)
 {
 	char filename[UTIL_PATH_SIZE];
@@ -594,7 +620,7 @@ static void export_initial_seqnum(struct udev *udev)
 	}
 	util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
 	util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
-	create_path(udev, filename);
+	util_create_path(udev, filename);
 	fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644);
 	if (fd >= 0) {
 		write(fd, seqnum, len);
@@ -605,10 +631,8 @@ static void export_initial_seqnum(struct udev *udev)
 int main(int argc, char *argv[])
 {
 	struct udev *udev;
-	int err;
 	int fd;
 	struct sigaction act;
-	fd_set readfds;
 	const char *value;
 	int daemonize = 0;
 	static const struct option options[] = {
@@ -620,7 +644,6 @@ int main(int argc, char *argv[])
 		{}
 	};
 	int rc = 1;
-	int maxfd;
 
 	udev = udev_new();
 	if (udev == NULL)
@@ -629,7 +652,7 @@ int main(int argc, char *argv[])
 	logging_init("udevd");
 	udev_set_log_fn(udev, log_fn);
 	info(udev, "version %s\n", VERSION);
-	selinux_init(udev);
+	udev_selinux_init(udev);
 
 	while (1) {
 		int option;
@@ -673,8 +696,6 @@ int main(int argc, char *argv[])
 		fprintf(stderr, "cannot open /dev/null\n");
 		err(udev, "cannot open /dev/null\n");
 	}
-	if (fd > STDIN_FILENO)
-		dup2(fd, STDIN_FILENO);
 	if (write(STDOUT_FILENO, 0, 0) < 0)
 		dup2(fd, STDOUT_FILENO);
 	if (write(STDERR_FILENO, 0, 0) < 0)
@@ -705,35 +726,13 @@ int main(int argc, char *argv[])
 	}
 	udev_monitor_set_receive_buffer_size(kernel_monitor, 128*1024*1024);
 
-	err = pipe(signal_pipe);
-	if (err < 0) {
-		err(udev, "error getting pipes: %m\n");
-		goto exit;
-	}
-
-	err = fcntl(signal_pipe[READ_END], F_GETFL, 0);
-	if (err < 0) {
-		err(udev, "error fcntl on read pipe: %m\n");
-		goto exit;
-	}
-	err = fcntl(signal_pipe[READ_END], F_SETFL, err | O_NONBLOCK);
-	if (err < 0) {
-		err(udev, "error fcntl on read pipe: %m\n");
-		goto exit;
-	}
-
-	err = fcntl(signal_pipe[WRITE_END], F_GETFL, 0);
-	if (err < 0) {
-		err(udev, "error fcntl on write pipe: %m\n");
-		goto exit;
-	}
-	err = fcntl(signal_pipe[WRITE_END], F_SETFL, err | O_NONBLOCK);
-	if (err < 0) {
-		err(udev, "error fcntl on write pipe: %m\n");
+	rules = udev_rules_new(udev, 1);
+	if (rules == NULL) {
+		err(udev, "error reading rules\n");
 		goto exit;
 	}
-
-	udev_rules_init(udev, &rules, 1);
+	udev_list_init(&event_list);
+	cleanup_queue_dir(udev);
 	export_initial_seqnum(udev);
 
 	if (daemonize) {
@@ -756,7 +755,8 @@ int main(int argc, char *argv[])
 	}
 
 	/* redirect std{out,err} */
-	if (!debug) {
+	if (!debug && !debug_trace) {
+		dup2(fd, STDIN_FILENO);
 		dup2(fd, STDOUT_FILENO);
 		dup2(fd, STDERR_FILENO);
 	}
@@ -790,9 +790,10 @@ int main(int argc, char *argv[])
 		util_strlcat(path, "/class/mem/null", sizeof(path));
 		if (lstat(path, &statbuf) == 0) {
 			if (S_ISDIR(statbuf.st_mode)) {
-				const char *depr_str = "<6>udev: deprecated sysfs layout (kernel too old, "
-							"or CONFIG_SYSFS_DEPRECATED) is unsupported, some "
-							"udev features may fail\n";
+				const char *depr_str =
+					"<6>udev: deprecated sysfs layout; update the kernel or "
+					"disable CONFIG_SYSFS_DEPRECATED; some udev features will "
+					"not work correctly\n";
 
 				write(fd, depr_str, strlen(depr_str));
 			}
@@ -804,7 +805,6 @@ int main(int argc, char *argv[])
 	memset(&act, 0x00, sizeof(struct sigaction));
 	act.sa_handler = (void (*)(int)) sig_handler;
 	sigemptyset(&act.sa_mask);
-	act.sa_flags = SA_RESTART;
 	sigaction(SIGINT, &act, NULL);
 	sigaction(SIGTERM, &act, NULL);
 	sigaction(SIGCHLD, &act, NULL);
@@ -817,7 +817,7 @@ int main(int argc, char *argv[])
 			inotify_add_watch(inotify_fd, udev_get_rules_path(udev),
 					  IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 		} else {
-			char filename[PATH_MAX];
+			char filename[UTIL_PATH_SIZE];
 
 			inotify_add_watch(inotify_fd, UDEV_PREFIX "/lib/udev/rules.d",
 					  IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
@@ -831,49 +831,69 @@ int main(int argc, char *argv[])
 					  IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 		}
 	} else if (errno == ENOSYS)
-		err(udev, "the kernel does not support inotify, udevd can't monitor rules file changes\n");
+		info(udev, "unable to use inotify, udevd will not monitor rule files changes\n");
 	else
 		err(udev, "inotify_init failed: %m\n");
 
-	/* maximum limit of forked childs */
-	value = getenv("UDEVD_MAX_CHILDS");
-	if (value)
-		max_childs = strtoul(value, NULL, 10);
-	else {
+	/* in trace mode run one event after the other */
+	if (debug_trace) {
+		max_childs = 1;
+	} else {
 		int memsize = mem_size_mb();
 		if (memsize > 0)
 			max_childs = 128 + (memsize / 4);
 		else
 			max_childs = UDEVD_MAX_CHILDS;
 	}
+	/* 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);
 
-	maxfd = udev_ctrl_get_fd(udev_ctrl);
-	maxfd = UDEV_MAX(maxfd, udev_monitor_get_fd(kernel_monitor));
-	maxfd = UDEV_MAX(maxfd, signal_pipe[READ_END]);
-	maxfd = UDEV_MAX(maxfd, inotify_fd);
 	while (!udev_exit) {
+		sigset_t blocked_mask, orig_mask;
+		struct pollfd pfd[4];
+		struct pollfd *ctrl_poll, *monitor_poll, *inotify_poll = NULL;
+		int nfds = 0;
 		int fdcount;
 
-		FD_ZERO(&readfds);
-		FD_SET(signal_pipe[READ_END], &readfds);
-		FD_SET(udev_ctrl_get_fd(udev_ctrl), &readfds);
-		FD_SET(udev_monitor_get_fd(kernel_monitor), &readfds);
-		if (inotify_fd >= 0)
-			FD_SET(inotify_fd, &readfds);
-		fdcount = select(maxfd+1, &readfds, NULL, NULL, NULL);
+		sigfillset(&blocked_mask);
+		sigprocmask(SIG_SETMASK, &blocked_mask, &orig_mask);
+		if (signal_received) {
+			sigprocmask(SIG_SETMASK, &orig_mask, NULL);
+			goto handle_signals;
+		}
+
+		ctrl_poll = &pfd[nfds++];
+		ctrl_poll->fd = udev_ctrl_get_fd(udev_ctrl);
+		ctrl_poll->events = POLLIN;
+
+		monitor_poll = &pfd[nfds++];
+		monitor_poll->fd = udev_monitor_get_fd(kernel_monitor);
+		monitor_poll->events = POLLIN;
+
+		if (inotify_fd >= 0) {
+			inotify_poll = &pfd[nfds++];
+			inotify_poll->fd = inotify_fd;
+			inotify_poll->events = POLLIN;
+		}
+
+		fdcount = ppoll(pfd, nfds, NULL, &orig_mask);
+		sigprocmask(SIG_SETMASK, &orig_mask, NULL);
 		if (fdcount < 0) {
-			if (errno != EINTR)
-				err(udev, "error in select: %m\n");
+			if (errno == EINTR)
+				goto handle_signals;
+			err(udev, "error in select: %m\n");
 			continue;
 		}
 
 		/* get control message */
-		if (FD_ISSET(udev_ctrl_get_fd(udev_ctrl), &readfds))
+		if (ctrl_poll->revents & POLLIN)
 			handle_ctrl_msg(udev_ctrl);
 
 		/* get kernel uevent */
-		if (FD_ISSET(udev_monitor_get_fd(kernel_monitor), &readfds)) {
+		if (monitor_poll->revents & POLLIN) {
 			struct udev_device *dev;
 
 			dev = udev_monitor_receive_device(kernel_monitor);
@@ -888,15 +908,8 @@ int main(int argc, char *argv[])
 			}
 		}
 
-		/* received a signal, clear our notification pipe */
-		if (FD_ISSET(signal_pipe[READ_END], &readfds)) {
-			char buf[256];
-
-			read(signal_pipe[READ_END], &buf, sizeof(buf));
-		}
-
 		/* rules directory inotify watch */
-		if ((inotify_fd >= 0) && FD_ISSET(inotify_fd, &readfds)) {
+		if (inotify_poll && (inotify_poll->revents & POLLIN)) {
 			int nbytes;
 
 			/* discard all possible events, we can just reload the config */
@@ -915,11 +928,19 @@ int main(int argc, char *argv[])
 			}
 		}
 
+handle_signals:
+		signal_received = 0;
+
 		/* rules changed, set by inotify or a HUP signal */
 		if (reload_config) {
+			struct udev_rules *rules_new;
+
 			reload_config = 0;
-			udev_rules_cleanup(&rules);
-			udev_rules_init(udev, &rules, 1);
+			rules_new = udev_rules_new(udev, 1);
+			if (rules_new != NULL) {
+				udev_rules_unref(rules);
+				rules = rules_new;
+			}
 		}
 
 		if (sigchilds_waiting) {
@@ -933,22 +954,15 @@ int main(int argc, char *argv[])
 				event_queue_manager(udev);
 		}
 	}
+	cleanup_queue_dir(udev);
 	rc = 0;
-
 exit:
-	udev_rules_cleanup(&rules);
-
-	if (signal_pipe[READ_END] >= 0)
-		close(signal_pipe[READ_END]);
-	if (signal_pipe[WRITE_END] >= 0)
-		close(signal_pipe[WRITE_END]);
-
+	udev_rules_unref(rules);
 	udev_ctrl_unref(udev_ctrl);
 	if (inotify_fd >= 0)
 		close(inotify_fd);
 	udev_monitor_unref(kernel_monitor);
-
-	selinux_exit(udev);
+	udev_selinux_exit(udev);
 	udev_unref(udev);
 	logging_close();
 	return rc;