X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udevd.c;h=5c51beed1e0d32d85a3d1332df28bfff19f964e9;hp=eb1080b190b9372f454370546fbfdf21d52236c2;hb=36dddd1ca40b4abbe3352b4cb93b465f4038666e;hpb=90cd961e2cb660b6c3ed9c9a33e8878f8aaa163c

diff --git a/udevd.c b/udevd.c
index eb1080b19..5c51beed1 100644
--- a/udevd.c
+++ b/udevd.c
@@ -1,7 +1,7 @@
 /*
  * udevd.c - event listener and serializer
  *
- * Copyright (C) 2004-2005 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2004-2006 Kay Sievers <kay.sievers@vrfy.org>
  * Copyright (C) 2004 Chris Friesen <chris_friesen@sympatico.ca>
  *
  *
@@ -47,9 +47,9 @@
 #include "udevd.h"
 
 static struct udev_rules rules;
-static int udevd_sock;
-static int uevent_netlink_sock;
-static int inotify_fd;
+static int udevd_sock = -1;
+static int uevent_netlink_sock = -1;
+static int inotify_fd = -1;
 static pid_t sid;
 
 static int signal_pipe[2] = {-1, -1};
@@ -86,7 +86,7 @@ static void asmlinkage udev_event_sig_handler(int signum)
 		exit(1);
 }
 
-static int udev_event_process(struct uevent_msg *msg)
+static int udev_event_process(struct udevd_uevent_msg *msg)
 {
 	struct sigaction act;
 	struct udevice *udev;
@@ -118,7 +118,7 @@ static int udev_event_process(struct uevent_msg *msg)
 	if (udev == NULL)
 		return -1;
 	strlcpy(udev->action, msg->action, sizeof(udev->action));
-	sysfs_device_set_values(udev->dev, msg->devpath, msg->subsystem);
+	sysfs_device_set_values(udev->dev, msg->devpath, msg->subsystem, msg->driver);
 	udev->devt = msg->devt;
 
 	retval = udev_device_event(&rules, udev);
@@ -153,13 +153,13 @@ enum event_state {
 	EVENT_FAILED,
 };
 
-static void export_event_state(struct uevent_msg *msg, enum event_state state)
+static void export_event_state(struct udevd_uevent_msg *msg, enum event_state state)
 {
 	char filename[PATH_SIZE];
 	char filename_failed[PATH_SIZE];
 	char target[PATH_SIZE];
 	size_t start, end, i;
-	struct uevent_msg *loop_msg;
+	struct udevd_uevent_msg *loop_msg;
 
 	/* add location of queue files */
 	strlcpy(filename, udev_root, sizeof(filename));
@@ -226,7 +226,7 @@ static void export_event_state(struct uevent_msg *msg, enum event_state state)
 	}
 }
 
-static void msg_queue_delete(struct uevent_msg *msg)
+static void msg_queue_delete(struct udevd_uevent_msg *msg)
 {
 	list_del(&msg->node);
 
@@ -239,7 +239,7 @@ static void msg_queue_delete(struct uevent_msg *msg)
 	free(msg);
 }
 
-static void udev_event_run(struct uevent_msg *msg)
+static void udev_event_run(struct udevd_uevent_msg *msg)
 {
 	pid_t pid;
 	int retval;
@@ -258,6 +258,7 @@ static void udev_event_run(struct uevent_msg *msg)
 
 		logging_init("udevd-event");
 		setpriority(PRIO_PROCESS, 0, UDEV_PRIORITY);
+
 		retval = udev_event_process(msg);
 		info("seq %llu finished", msg->seqnum);
 
@@ -277,7 +278,7 @@ static void udev_event_run(struct uevent_msg *msg)
 	}
 }
 
-static void msg_queue_insert(struct uevent_msg *msg)
+static void msg_queue_insert(struct udevd_uevent_msg *msg)
 {
 	char filename[PATH_SIZE];
 	int fd;
@@ -309,11 +310,72 @@ static void msg_queue_insert(struct uevent_msg *msg)
 	run_exec_q = 1;
 }
 
-/* runs event and removes event from run queue when finished */
+static int mem_size_mb(void)
+{
+	int f;
+	char buf[8192];
+	long int len;
+	const char *pos;
+	long int memsize;
+
+	f = open("/proc/meminfo", O_RDONLY);
+	if (f == -1)
+		return -1;
+
+	len = read(f, buf, sizeof(buf)-1);
+	close(f);
+
+	if (len <= 0)
+		return -1;
+	buf[len] = '\0';
+
+	pos = strstr(buf, "MemTotal: ");
+	if (pos == NULL)
+		return -1;
+
+	if (sscanf(pos, "MemTotal: %ld kB", &memsize) != 1)
+		return -1;
+
+	return memsize / 1024;
+}
+
+static int cpu_count(void)
+{
+	int f;
+	char buf[32768];
+	int len;
+	const char *pos;
+	int count = 0;
+
+	f = open("/proc/stat", O_RDONLY);
+	if (f == -1)
+		return -1;
+
+	len = read(f, buf, sizeof(buf)-1);
+	close(f);
+	if (len <= 0)
+		return -1;
+	buf[len] = '\0';
+
+	pos = strstr(buf, "cpu");
+	if (pos == NULL)
+		return -1;
+
+	while (pos != NULL) {
+		if (strncmp(pos, "cpu", 3) == 0 &&isdigit(pos[3]))
+			count++;
+		pos = strstr(&pos[3], "cpu");
+	}
+
+	if (count == 0)
+		return -1;
+	return count;
+}
+
 static int running_processes(void)
 {
 	int f;
-	static char buf[4096];
+	char buf[32768];
 	int len;
 	int running;
 	const char *pos;
@@ -324,11 +386,9 @@ static int running_processes(void)
 
 	len = read(f, buf, sizeof(buf)-1);
 	close(f);
-
 	if (len <= 0)
 		return -1;
-	else
-		buf[len] = '\0';
+	buf[len] = '\0';
 
 	pos = strstr(buf, "procs_running ");
 	if (pos == NULL)
@@ -430,9 +490,9 @@ static int compare_devpath(const char *running, const char *waiting)
 }
 
 /* returns still running task for the same device, its parent or its physical device */
-static int running_with_devpath(struct uevent_msg *msg, int limit)
+static int running_with_devpath(struct udevd_uevent_msg *msg, int limit)
 {
-	struct uevent_msg *loop_msg;
+	struct udevd_uevent_msg *loop_msg;
 	int childs_count = 0;
 
 	list_for_each_entry(loop_msg, &running_list, node) {
@@ -463,8 +523,8 @@ static int running_with_devpath(struct uevent_msg *msg, int limit)
 /* exec queue management routine executes the events and serializes events in the same sequence */
 static void msg_queue_manager(void)
 {
-	struct uevent_msg *loop_msg;
-	struct uevent_msg *tmp_msg;
+	struct udevd_uevent_msg *loop_msg;
+	struct udevd_uevent_msg *tmp_msg;
 	int running;
 
 	if (list_empty(&exec_list))
@@ -500,18 +560,18 @@ static void msg_queue_manager(void)
 	}
 }
 
-static struct uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size)
+static struct udevd_uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size)
 {
 	int bufpos;
 	int i;
-	struct uevent_msg *msg;
+	struct udevd_uevent_msg *msg;
 	int major = 0;
 	int minor = 0;
 
-	msg = malloc(sizeof(struct uevent_msg) + buf_size);
+	msg = malloc(sizeof(struct udevd_uevent_msg) + buf_size);
 	if (msg == NULL)
 		return NULL;
-	memset(msg, 0x00, sizeof(struct uevent_msg) + buf_size);
+	memset(msg, 0x00, sizeof(struct udevd_uevent_msg) + buf_size);
 
 	/* copy environment buffer and reconstruct envp */
 	memcpy(msg->envbuf, buf, buf_size);
@@ -533,6 +593,8 @@ static struct uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size)
 			msg->devpath = &key[8];
 		else if (strncmp(key, "SUBSYSTEM=", 10) == 0)
 			msg->subsystem = &key[10];
+		else if (strncmp(key, "DRIVER=", 7) == 0)
+			msg->driver = &key[7];
 		else if (strncmp(key, "SEQNUM=", 7) == 0)
 			msg->seqnum = strtoull(&key[7], NULL, 10);
 		else if (strncmp(key, "PHYSDEVPATH=", 12) == 0)
@@ -557,22 +619,20 @@ static struct uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size)
 }
 
 /* receive the udevd message from userspace */
-static struct uevent_msg *get_udevd_msg(void)
+static void get_ctrl_msg(void)
 {
-	static struct udevd_msg usend_msg;
-	struct uevent_msg *msg;
+	struct udevd_ctrl_msg ctrl_msg;
 	ssize_t size;
 	struct msghdr smsg;
 	struct cmsghdr *cmsg;
 	struct iovec iov;
 	struct ucred *cred;
 	char cred_msg[CMSG_SPACE(sizeof(struct ucred))];
-	int envbuf_size;
 	int *intval;
 
-	memset(&usend_msg, 0x00, sizeof(struct udevd_msg));
-	iov.iov_base = &usend_msg;
-	iov.iov_len = sizeof(struct udevd_msg);
+	memset(&ctrl_msg, 0x00, sizeof(struct udevd_ctrl_msg));
+	iov.iov_base = &ctrl_msg;
+	iov.iov_len = sizeof(struct udevd_ctrl_msg);
 
 	memset(&smsg, 0x00, sizeof(struct msghdr));
 	smsg.msg_iov = &iov;
@@ -584,71 +644,66 @@ static struct uevent_msg *get_udevd_msg(void)
 	if (size <  0) {
 		if (errno != EINTR)
 			err("unable to receive user udevd message: %s", strerror(errno));
-		return NULL;
+		return;
 	}
 	cmsg = CMSG_FIRSTHDR(&smsg);
 	cred = (struct ucred *) CMSG_DATA(cmsg);
 
 	if (cmsg == NULL || cmsg->cmsg_type != SCM_CREDENTIALS) {
 		err("no sender credentials received, message ignored");
-		return NULL;
+		return;
 	}
 
 	if (cred->uid != 0) {
 		err("sender uid=%i, message ignored", cred->uid);
-		return NULL;
+		return;
 	}
 
-	if (strncmp(usend_msg.magic, UDEV_MAGIC, sizeof(UDEV_MAGIC)) != 0 ) {
-		err("message magic '%s' doesn't match, ignore it", usend_msg.magic);
-		return NULL;
+	if (strncmp(ctrl_msg.magic, UDEVD_CTRL_MAGIC, sizeof(UDEVD_CTRL_MAGIC)) != 0 ) {
+		err("message magic '%s' doesn't match, ignore it", ctrl_msg.magic);
+		return;
 	}
 
-	switch (usend_msg.type) {
-	case UDEVD_UEVENT_UDEVSEND:
-		info("udevd event message received");
-		envbuf_size = size - offsetof(struct udevd_msg, envbuf);
-		dbg("envbuf_size=%i", envbuf_size);
-		msg = get_msg_from_envbuf(usend_msg.envbuf, envbuf_size);
-		if (msg == NULL)
-			return NULL;
-		msg->type = usend_msg.type;
-		return msg;
-	case UDEVD_STOP_EXEC_QUEUE:
+	switch (ctrl_msg.type) {
+	case UDEVD_CTRL_STOP_EXEC_QUEUE:
 		info("udevd message (STOP_EXEC_QUEUE) received");
 		stop_exec_q = 1;
 		break;
-	case UDEVD_START_EXEC_QUEUE:
+	case UDEVD_CTRL_START_EXEC_QUEUE:
 		info("udevd message (START_EXEC_QUEUE) received");
 		stop_exec_q = 0;
 		msg_queue_manager();
 		break;
-	case UDEVD_SET_LOG_LEVEL:
-		intval = (int *) usend_msg.envbuf;
+	case UDEVD_CTRL_SET_LOG_LEVEL:
+		intval = (int *) ctrl_msg.buf;
 		info("udevd message (SET_LOG_PRIORITY) received, udev_log_priority=%i", *intval);
 		udev_log_priority = *intval;
 		sprintf(udev_log, "UDEV_LOG=%i", udev_log_priority);
 		putenv(udev_log);
 		break;
-	case UDEVD_SET_MAX_CHILDS:
-		intval = (int *) usend_msg.envbuf;
+	case UDEVD_CTRL_SET_MAX_CHILDS:
+		intval = (int *) ctrl_msg.buf;
 		info("udevd message (UDEVD_SET_MAX_CHILDS) received, max_childs=%i", *intval);
 		max_childs = *intval;
 		break;
-	case UDEVD_RELOAD_RULES:
+	case UDEVD_CTRL_SET_MAX_CHILDS_RUNNING:
+		intval = (int *) ctrl_msg.buf;
+		info("udevd message (UDEVD_SET_MAX_CHILDS_RUNNING) received, max_childs=%i", *intval);
+		max_childs_running = *intval;
+		break;
+	case UDEVD_CTRL_RELOAD_RULES:
 		info("udevd message (RELOAD_RULES) received");
 		reload_config = 1;
 		break;
 	default:
-		dbg("unknown message type");
+		err("unknown control message type");
 	}
-	return NULL;
 }
 
 /* receive the kernel user event message and do some sanity checks */
-static struct uevent_msg *get_netlink_msg(void)
+static struct udevd_uevent_msg *get_netlink_msg(void)
 {
-	struct uevent_msg *msg;
+	struct udevd_uevent_msg *msg;
 	int bufpos;
 	ssize_t size;
 	static char buffer[UEVENT_BUFFER_SIZE+512];
@@ -671,7 +726,6 @@ static struct uevent_msg *get_netlink_msg(void)
 	msg = get_msg_from_envbuf(&buffer[bufpos], size-bufpos);
 	if (msg == NULL)
 		return NULL;
-	msg->type = UDEVD_UEVENT_NETLINK;
 
 	/* validate message */
 	pos = strchr(buffer, '@');
@@ -720,7 +774,7 @@ static void asmlinkage sig_handler(int signum)
 static void udev_done(int pid, int exitstatus)
 {
 	/* find msg associated with pid and delete it */
-	struct uevent_msg *msg;
+	struct udevd_uevent_msg *msg;
 
 	list_for_each_entry(msg, &running_list, node) {
 		if (msg->pid == pid) {
@@ -758,7 +812,6 @@ static void reap_sigchilds(void)
 static int init_udevd_socket(void)
 {
 	struct sockaddr_un saddr;
-	const int buffersize = 16 * 1024 * 1024;
 	socklen_t addrlen;
 	const int feature_on = 1;
 	int retval;
@@ -766,7 +819,7 @@ static int init_udevd_socket(void)
 	memset(&saddr, 0x00, sizeof(saddr));
 	saddr.sun_family = AF_LOCAL;
 	/* use abstract namespace for socket path */
-	strcpy(&saddr.sun_path[1], UDEVD_SOCK_PATH);
+	strcpy(&saddr.sun_path[1], UDEVD_CTRL_SOCK_PATH);
 	addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(saddr.sun_path+1) + 1;
 
 	udevd_sock = socket(AF_LOCAL, SOCK_DGRAM, 0);
@@ -775,13 +828,12 @@ static int init_udevd_socket(void)
 		return -1;
 	}
 
-	/* set receive buffersize */
-	setsockopt(udevd_sock, SOL_SOCKET, SO_RCVBUFFORCE, &buffersize, sizeof(buffersize));
-
 	/* the bind takes care of ensuring only one copy running */
 	retval = bind(udevd_sock, (struct sockaddr *) &saddr, addrlen);
 	if (retval < 0) {
 		err("bind failed: %s", strerror(errno));
+		close(udevd_sock);
+		udevd_sock = -1;
 		return -1;
 	}
 
@@ -800,7 +852,7 @@ static int init_uevent_netlink_sock(void)
 	memset(&snl, 0x00, sizeof(struct sockaddr_nl));
 	snl.nl_family = AF_NETLINK;
 	snl.nl_pid = getpid();
-	snl.nl_groups = 0xffffffff;
+	snl.nl_groups = 1;
 
 	uevent_netlink_sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
 	if (uevent_netlink_sock == -1) {
@@ -841,6 +893,7 @@ static void export_initial_seqnum(void)
 	}
 	strlcpy(filename, udev_root, sizeof(filename));
 	strlcat(filename, "/" EVENT_SEQNUM, sizeof(filename));
+	create_path(filename);
 	fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644);
 	if (fd >= 0) {
 		write(fd, seqnum, len);
@@ -892,10 +945,6 @@ int main(int argc, char *argv[], char *envp[])
 			info("will daemonize");
 			daemonize = 1;
 		}
-		if (strcmp(arg, "--stop-exec-queue") == 0) {
-			info("will not execute events until START_EXEC_QUEUE is received");
-			stop_exec_q = 1;
-		}
 	}
 
 	/* init sockets to receive events */
@@ -1011,16 +1060,26 @@ int main(int argc, char *argv[], char *envp[])
 	value = getenv("UDEVD_MAX_CHILDS");
 	if (value)
 		max_childs = strtoul(value, NULL, 10);
-	else
-		max_childs = UDEVD_MAX_CHILDS;
+	else {
+		int memsize = mem_size_mb();
+		if (memsize > 0)
+			max_childs = 128 + (memsize / 4);
+		else
+			max_childs = UDEVD_MAX_CHILDS;
+	}
 	info("initialize max_childs to %u", max_childs);
 
 	/* start to throttle forking if maximum number of _running_ childs is reached */
 	value = getenv("UDEVD_MAX_CHILDS_RUNNING");
 	if (value)
 		max_childs_running = strtoull(value, NULL, 10);
-	else
-		max_childs_running = UDEVD_MAX_CHILDS_RUNNING;
+	else {
+		int cpus = cpu_count();
+		if (cpus > 0)
+			max_childs_running = 8 + (8 * cpus);
+		else
+			max_childs_running = UDEVD_MAX_CHILDS_RUNNING;
+	}
 	info("initialize max_childs_running to %u", max_childs_running);
 
 	/* clear environment for forked event processes */
@@ -1036,7 +1095,7 @@ int main(int argc, char *argv[], char *envp[])
 	maxfd = UDEV_MAX(maxfd, inotify_fd);
 
 	while (!udev_exit) {
-		struct uevent_msg *msg;
+		struct udevd_uevent_msg *msg;
 		int fdcount;
 
 		FD_ZERO(&readfds);
@@ -1053,14 +1112,11 @@ int main(int argc, char *argv[], char *envp[])
 			continue;
 		}
 
-		/* get user socket message */
-		if (FD_ISSET(udevd_sock, &readfds)) {
-			msg = get_udevd_msg();
-			if (msg)
-				msg_queue_insert(msg);
-		}
+		/* get control message */
+		if (FD_ISSET(udevd_sock, &readfds))
+			get_ctrl_msg();
 
-		/* get kernel netlink message */
+		/* get netlink message */
 		if (FD_ISSET(uevent_netlink_sock, &readfds)) {
 			msg = get_netlink_msg();
 			if (msg)