X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=udevd.c;h=26e6b23486b23963fa34cfb09ed102520deded59;hb=a695feaeff0551745e1a397be2daa61b8cd0cc42;hp=08dede36ee335c597c2616709c24643195b9ec1a;hpb=7fafc0324272731c5666047715b9f58f56761534;p=elogind.git

diff --git a/udevd.c b/udevd.c
index 08dede36e..26e6b2348 100644
--- a/udevd.c
+++ b/udevd.c
@@ -22,8 +22,10 @@
  *
  */
 
+#include <stddef.h>
 #include <sys/types.h>
 #include <sys/ipc.h>
+#include <sys/wait.h>
 #include <sys/msg.h>
 #include <signal.h>
 #include <unistd.h>
@@ -31,56 +33,38 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
+#include <fcntl.h>
 
+#include "list.h"
 #include "udev.h"
 #include "udevd.h"
 #include "logging.h"
 
-#define BUFFER_SIZE		1024
-#define TIMEOUT_SECONDS		10
-
-static void reset_timer(void);
-static void reset_queue(void);
-
+#define BUFFER_SIZE			1024
 
 static int expect_seqnum = 0;
-static int timeout_value = TIMEOUT_SECONDS;
-static int timeout = 0;
-static struct hotplug_msg *head = NULL;
-static char exec_program[100];
-
-static void sig_handler(int signum)
-{
-	dbg("caught signal %d", signum);
-	switch (signum) {
-		case SIGHUP:
-			dbg("reset requested, all waiting events killed");
-			reset_timer();
-			reset_queue();
-			timeout = 0;
-			expect_seqnum = 0;
-			break;
+static int lock_file = -1;
+static char *lock_filename = ".udevd_lock";
 
-		case SIGINT:
-		case SIGTERM:
-		case SIGKILL:
-			exit(20 + signum);
-			break;
+LIST_HEAD(msg_list);
 
-		default:
-			dbg("unhandled signal");
-	}
-}
-
-static void sig_alarmhandler(int signum)
+static void sig_handler(int signum)
 {
 	dbg("caught signal %d", signum);
 	switch (signum) {
 	case SIGALRM:
-		timeout = 1;
 		dbg("event timeout reached");
 		break;
-
+	case SIGINT:
+	case SIGTERM:
+	case SIGKILL:
+		if (lock_file >= 0) {
+			close(lock_file);
+			unlink(lock_filename);
+		}
+		exit(20 + signum);
+		break;
 	default:
 		dbg("unhandled signal");
 	}
@@ -88,168 +72,206 @@ static void sig_alarmhandler(int signum)
 
 static void dump_queue(void)
 {
-	struct hotplug_msg *p;
-	p = head;
+	struct hotplug_msg *msg;
 
-	dbg("next expected sequence is %d", expect_seqnum);
-	while(p) {
-		dbg("sequence %d in queue", p->seqnum);
-		p=p->next;
-	}
+	list_for_each_entry(msg, &msg_list, list)
+		dbg("sequence %d in queue", msg->seqnum);
 }
 
-static void dump_msg(struct hotplug_msg *pmsg)
+static void dump_msg(struct hotplug_msg *msg)
 {
 	dbg("sequence %d, '%s', '%s', '%s'",
-	    pmsg->seqnum, pmsg->action, pmsg->devpath, pmsg->subsystem);
+	    msg->seqnum, msg->action, msg->devpath, msg->subsystem);
 }
 
-static void dispatch_msg(struct hotplug_msg *pmsg)
+static int dispatch_msg(struct hotplug_msg *msg)
 {
-	dump_msg(pmsg);
-	dbg("exec '%s'", exec_program);
-	setenv("ACTION", pmsg->action, 1);
-	setenv("DEVPATH", pmsg->devpath, 1);
-	execl(exec_program, pmsg->subsystem);
-}
+	pid_t pid;
 
-static void reset_timer(void)
-{
-	alarm(0);
-}
+	dump_msg(msg);
 
-static void set_timer(void)
-{
-	signal(SIGALRM, sig_alarmhandler);
-	alarm(timeout_value);
+	setenv("ACTION", msg->action, 1);
+	setenv("DEVPATH", msg->devpath, 1);
+
+	pid = fork();
+	switch (pid) {
+	case 0:
+		/* child */
+		execl(UDEV_EXEC, "udev", msg->subsystem, NULL);
+		dbg("exec of child failed");
+		exit(1);
+		break;
+	case -1:
+		dbg("fork of child failed");
+		return -1;
+	default:
+		wait(NULL);
+	}
+	return 0;
 }
 
-static void reset_queue(void)
+static void set_timeout(int seconds)
 {
-	struct hotplug_msg *p;
-	p = head;
-
-	while(head) {
-		p = head;
-		head = head->next;
-		free(p);
-	}
+	alarm(seconds);
+	dbg("set timeout in %d seconds", seconds);
 }
 
 static void check_queue(void)
 {
-	struct hotplug_msg *p;
-	p = head;
+	struct hotplug_msg *msg;
+	struct hotplug_msg *tmp_msg;
+	time_t msg_age;
 
-	dump_queue();
-	while(head && head->seqnum == expect_seqnum) {
-		dispatch_msg(head);
+recheck:
+	/* dispatch events until one is missing */
+	list_for_each_entry_safe(msg, tmp_msg, &msg_list, list) {
+		if (msg->seqnum != expect_seqnum)
+			break;
+		dispatch_msg(msg);
 		expect_seqnum++;
-		p = head;
-		head = head->next;
-		free(p);
+		list_del_init(&msg->list);
+		free(msg);
+	}
+
+	/* recalculate timeout */
+	if (list_empty(&msg_list) == 0) {
+		msg_age = time(NULL) - msg->queue_time;
+		if (msg_age > EVENT_TIMEOUT_SECONDS-1) {
+			info("event %d, age %li seconds, skip event %d-%d",
+			     msg->seqnum, msg_age, expect_seqnum, msg->seqnum-1);
+			expect_seqnum = msg->seqnum;
+			goto recheck;
+		}
+		set_timeout(EVENT_TIMEOUT_SECONDS - msg_age);
+		return;
 	}
-	if (head != NULL)
-		set_timer();
-	else
-		reset_timer();
+
+	/* queue is empty */
+	set_timeout(UDEVD_TIMEOUT_SECONDS);
 }
 
-static void add_queue(struct hotplug_msg *pmsg)
+static int queue_msg(struct hotplug_msg *msg)
 {
-	struct hotplug_msg *pnewmsg;
-	struct hotplug_msg *p;
-	struct hotplug_msg *p1;
-
-	p = head;
-	p1 = NULL;
-	pnewmsg = malloc(sizeof(struct hotplug_msg));
-	*pnewmsg = *pmsg;
-	pnewmsg->next = NULL;
-	while(p && pmsg->seqnum > p->seqnum) {
-		p1 = p;
-		p = p->next;
-	}
-	pnewmsg->next = p;
-	if (p1 == NULL) {
-		head = pnewmsg;
-	} else {
-		p1->next = pnewmsg;
+	struct hotplug_msg *new_msg;
+	struct hotplug_msg *tmp_msg;
+
+	new_msg = malloc(sizeof(*new_msg));
+	if (new_msg == NULL) {
+		dbg("error malloc");
+		return -ENOMEM;
 	}
-	dump_queue();
+	memcpy(new_msg, msg, sizeof(*new_msg));
+
+	/* store timestamp of queuing */
+	new_msg->queue_time = time(NULL);
+
+	/* sort message by sequence number into list*/
+	list_for_each_entry(tmp_msg, &msg_list, list)
+		if (tmp_msg->seqnum > new_msg->seqnum)
+			break;
+	list_add_tail(&new_msg->list, &tmp_msg->list);
+
+	return 0;
 }
 
-static int process_queue(void)
+static void work(void)
 {
+	struct hotplug_msg *msg;
 	int msgid;
 	key_t key;
-	struct hotplug_msg *pmsg;
 	char buf[BUFFER_SIZE];
 	int ret;
 
-	key = ftok(DEFAULT_EXEC_PROGRAM, IPC_KEY_ID);
-	pmsg = (struct hotplug_msg *) buf;
+	key = ftok(UDEVD_EXEC, IPC_KEY_ID);
+	msg = (struct hotplug_msg *) buf;
 	msgid = msgget(key, IPC_CREAT);
 	if (msgid == -1) {
 		dbg("open message queue error");
-		goto exit;
+		exit(1);
 	}
 	while (1) {
 		ret = msgrcv(msgid, (struct msgbuf *) buf, BUFFER_SIZE-4, HOTPLUGMSGTYPE, 0);
 		if (ret != -1) {
-			dbg("current sequence %d, expected sequence %d", pmsg->seqnum, expect_seqnum);
-
-			/* init expected sequence with value from first call */
+			/* init the expected sequence with value from first call */
 			if (expect_seqnum == 0) {
-				expect_seqnum = pmsg->seqnum;
+				expect_seqnum = msg->seqnum;
 				dbg("init next expected sequence number to %d", expect_seqnum);
 			}
-
-			if (pmsg->seqnum > expect_seqnum) {
-				add_queue(pmsg);
-				set_timer();
-			} else {
-				if (pmsg->seqnum == expect_seqnum) {
-					dispatch_msg(pmsg);
-					expect_seqnum++;
-					check_queue();
-				} else {
-					dbg("timeout event for unexpected sequence number %d", pmsg->seqnum);
-				}
+			dbg("current sequence %d, expected sequence %d", msg->seqnum, expect_seqnum);
+			if (msg->seqnum == expect_seqnum) {
+				/* execute expected event */
+				dispatch_msg(msg);
+				expect_seqnum++;
+				check_queue();
+				dump_queue();
+				continue;
+			}
+			if (msg->seqnum > expect_seqnum) {
+				/* something missing, queue event*/
+				queue_msg(msg);
+				check_queue();
+				dump_queue();
+				continue;
 			}
-		} else
+			dbg("too late for event with sequence %d, even skipped ", msg->seqnum);
+		} else {
 			if (errno == EINTR) {
-				if (head != NULL) {
-					/* timeout, skip all missing, proceed with next queued event */
-					dbg("timeout reached, skip events %d - %d", expect_seqnum, head->seqnum-1);
-					expect_seqnum = head->seqnum;
+				/* timeout */
+				if (list_empty(&msg_list)) {
+					info("we have nothing to do, so daemon exits...");
+					if (lock_file >= 0) {
+						close(lock_file);
+						unlink(lock_filename);
+					}
+					exit(0);
 				}
 				check_queue();
-				timeout = 0;
-			} else {
-				dbg("ipc message receive error '%s'", strerror(errno));
+				dump_queue();
+				continue;
 			}
+			dbg("ipc message receive error '%s'", strerror(errno));
+		}
 	}
+}
+
+static int one_and_only(void)
+{
+	char string[100];
+
+	lock_file = open(lock_filename, O_RDWR | O_CREAT, 0x640);
+
+	/* see if we can open */
+	if (lock_file < 0)
+		return -1;
+	
+	/* see if we can lock */
+	if (lockf(lock_file, F_TLOCK, 0) < 0) {
+		close(lock_file);
+		unlink(lock_filename);
+		return -1;
+	}
+
+	snprintf(string, sizeof(string), "%d\n", getpid());
+	write(lock_file, string, strlen(string));
+
 	return 0;
-exit:
-	return -1;
 }
 
 int main(int argc, char *argv[])
 {
-	/* get program to exec on events */
-	if (argc == 2)
-		strncpy(exec_program, argv[1], sizeof(exec_program));
-	else
-		strcpy(exec_program, DEFAULT_EXEC_PROGRAM);
+	/* only let one version of the daemon run at any one time */
+	if (one_and_only() != 0)
+		exit(0);
 
 	/* set up signal handler */
 	signal(SIGINT, sig_handler);
 	signal(SIGTERM, sig_handler);
 	signal(SIGKILL, sig_handler);
-	signal(SIGHUP, sig_handler);
+	signal(SIGALRM, sig_handler);
 
-	/* main loop */
-	process_queue();
-	return 0;
+	/* we exit if we have nothing to do, next event will start us again */
+	set_timeout(UDEVD_TIMEOUT_SECONDS);
+
+	work();
+	exit(0);
 }