X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udevd.c;h=22c38653e7712b68c30822952ccc857d38bb5164;hp=2e63d8030e4035827e28a8fb42e780c7d8feda74;hb=bc59f0167a03be2d2e4cf8a680dda8444243c64f;hpb=1c5c245e6f053da7ac147a1733ea49dd84f260a5 diff --git a/udevd.c b/udevd.c index 2e63d8030..22c38653e 100644 --- a/udevd.c +++ b/udevd.c @@ -22,6 +22,7 @@ * */ +#include #include #include #include @@ -32,71 +33,156 @@ #include #include #include +#include #include +#include "list.h" #include "udev.h" +#include "udev_version.h" #include "udevd.h" #include "logging.h" + #define BUFFER_SIZE 1024 -#define EVENT_TIMEOUT_SECONDS 10 -#define DAEMON_TIMEOUT_SECONDS 30 +static int running_remove_queue(pid_t pid); +static int msg_exec(struct hotplug_msg *msg); static int expect_seqnum = 0; -static struct hotplug_msg *head = NULL; +static int lock_file = -1; +static char *lock_filename = ".udevd_lock"; +LIST_HEAD(msg_list); +LIST_HEAD(running_list); +LIST_HEAD(delayed_list); -static void sig_alarmhandler(int signum) +static void sig_handler(int signum) { + pid_t pid; + dbg("caught signal %d", signum); switch (signum) { case SIGALRM: dbg("event timeout reached"); break; - + case SIGCHLD: + /* catch signals from exiting childs */ + while ( (pid = waitpid(-1, NULL, WNOHANG)) > 0) { + dbg("exec finished, pid %d", pid); + running_remove_queue(pid); + } + break; + case SIGINT: + case SIGTERM: + if (lock_file >= 0) { + close(lock_file); + unlink(lock_filename); + } + exit(20 + signum); + break; default: dbg("unhandled signal"); } } -static void dump_queue(void) +static void set_timeout(int seconds) { - struct hotplug_msg *p; - p = head; + alarm(seconds); + dbg("set timeout in %d seconds", seconds); +} - dbg("next expected sequence is %d", expect_seqnum); - while(p != NULL) { - dbg("sequence %d in queue", p->seqnum); - p = p->next; - } +static int running_moveto_queue(struct hotplug_msg *msg) +{ + dbg("move sequence %d [%d] to running queue '%s'", + msg->seqnum, msg->pid, msg->devpath); + list_move_tail(&msg->list, &running_list); + return 0; } -static void dump_msg(struct hotplug_msg *pmsg) +static int running_remove_queue(pid_t pid) +{ + struct hotplug_msg *child; + struct hotplug_msg *tmp_child; + + list_for_each_entry_safe(child, tmp_child, &running_list, list) + if (child->pid == pid) { + list_del_init(&child->list); + free(child); + return 0; + } + return -EINVAL; +} + +static pid_t running_getpid_by_devpath(struct hotplug_msg *msg) +{ + struct hotplug_msg *child; + struct hotplug_msg *tmp_child; + + list_for_each_entry_safe(child, tmp_child, &running_list, list) + if (strncmp(child->devpath, msg->devpath, sizeof(child->devpath)) == 0) + return child->pid; + return 0; +} + +static void delayed_dump_queue(void) +{ + struct hotplug_msg *child; + + list_for_each_entry(child, &delayed_list, list) + dbg("event for '%s' in queue", child->devpath); +} + +static int delayed_moveto_queue(struct hotplug_msg *msg) +{ + dbg("move event to delayed queue '%s'", msg->devpath); + list_move_tail(&msg->list, &delayed_list); + return 0; +} + +static void delayed_check_queue(void) +{ + struct hotplug_msg *delayed_child; + struct hotplug_msg *running_child; + struct hotplug_msg *tmp_child; + + /* see if we have delayed exec's that can run now */ + list_for_each_entry_safe(delayed_child, tmp_child, &delayed_list, list) + list_for_each_entry_safe(running_child, tmp_child, &running_list, list) + if (strncmp(delayed_child->devpath, running_child->devpath, + sizeof(running_child->devpath)) == 0) { + dbg("delayed exec for '%s' can run now", delayed_child->devpath); + msg_exec(delayed_child); + } +} + +static void msg_dump(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 int dispatch_msg(struct hotplug_msg *pmsg) +static int msg_exec(struct hotplug_msg *msg) { pid_t pid; - char *argv[3]; - extern char **environ; - dump_msg(pmsg); + msg_dump(msg); + + setenv("ACTION", msg->action, 1); + setenv("DEVPATH", msg->devpath, 1); - setenv("ACTION", pmsg->action, 1); - setenv("DEVPATH", pmsg->devpath, 1); - argv[0] = DEFAULT_UDEV_EXEC; - argv[1] = pmsg->subsystem; - argv[2] = NULL; + /* delay exec, if we already have a udev working on the same devpath */ + pid = running_getpid_by_devpath(msg); + if (pid != 0) { + dbg("delay exec of sequence %d, [%d] already working on '%s'", + msg->seqnum, pid, msg->devpath); + delayed_moveto_queue(msg); + } pid = fork(); switch (pid) { case 0: /* child */ - execve(argv[0], argv, environ); + execl(UDEV_BIN, "udev", msg->subsystem, NULL); dbg("exec of child failed"); exit(1); break; @@ -104,141 +190,119 @@ static int dispatch_msg(struct hotplug_msg *pmsg) dbg("fork of child failed"); return -1; default: - wait(0); + /* exec in background, get the SIGCHLD with the sig handler */ + msg->pid = pid; + running_moveto_queue(msg); + break; } return 0; } -static void set_timer(int seconds) +static void msg_dump_queue(void) { - signal(SIGALRM, sig_alarmhandler); - alarm(seconds); + struct hotplug_msg *msg; + + list_for_each_entry(msg, &msg_list, list) + dbg("sequence %d in queue", msg->seqnum); } -static void check_queue(void) +static void msg_check_queue(void) { - struct hotplug_msg *p; - p = head; - - dump_queue(); - while(head != NULL && head->seqnum == expect_seqnum) { - dispatch_msg(head); + struct hotplug_msg *msg; + struct hotplug_msg *tmp_msg; + time_t msg_age; + +recheck: + /* dispatch events until one is missing */ + list_for_each_entry_safe(msg, tmp_msg, &msg_list, list) { + if (msg->seqnum != expect_seqnum) + break; + msg_exec(msg); expect_seqnum++; - p = head; - head = head->next; - free(p); } - if (head != NULL) - set_timer(EVENT_TIMEOUT_SECONDS); - else - set_timer(DAEMON_TIMEOUT_SECONDS); + + /* recalculate next timeout */ + if (list_empty(&msg_list) == 0) { + msg_age = time(NULL) - msg->queue_time; + if (msg_age > EVENT_TIMEOUT_SEC-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; + } + + /* the first sequence gets its own timeout */ + if (expect_seqnum == 0) { + msg_age = EVENT_TIMEOUT_SEC - FIRST_EVENT_TIMEOUT_SEC; + expect_seqnum = 1; + } + + set_timeout(EVENT_TIMEOUT_SEC - msg_age); + return; + } } -static void add_queue(struct hotplug_msg *pmsg) +static int msg_add_queue(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 != NULL && 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)); -static int lock_file = -1; -static char *lock_filename = ".udevd_lock"; + /* 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); -static int process_queue(void) + return 0; +} + +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_UDEVD_EXEC, IPC_KEY_ID); - pmsg = (struct hotplug_msg *) buf; + key = ftok(UDEVD_BIN, IPC_KEY_ID); + msg = (struct hotplug_msg *) buf; msgid = msgget(key, IPC_CREAT); if (msgid == -1) { dbg("open message queue error"); - return -1; + 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 */ - if (expect_seqnum == 0) { - expect_seqnum = pmsg->seqnum; - dbg("init next expected sequence number to %d", expect_seqnum); - } - - if (pmsg->seqnum > expect_seqnum) { - add_queue(pmsg); - set_timer(EVENT_TIMEOUT_SECONDS); - } 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("received sequence %d, expected sequence %d", msg->seqnum, expect_seqnum); + if (msg->seqnum >= expect_seqnum) { + msg_add_queue(msg); + msg_dump_queue(); + msg_check_queue(); + continue; } + dbg("too late for event with sequence %d, event skipped ", msg->seqnum); } else { if (errno == EINTR) { - if (head != NULL) { - /* event timeout, skip all missing, proceed with next queued event */ - info("timeout reached, skip events %d - %d", expect_seqnum, head->seqnum-1); - expect_seqnum = head->seqnum; - } else { - info("we have nothing to do, so daemon exits..."); - if (lock_file >= 0) { - close(lock_file); - unlink(lock_filename); - } - exit(0); - } - check_queue(); - } else { - dbg("ipc message receive error '%s'", strerror(errno)); + msg_check_queue(); + msg_dump_queue(); + delayed_check_queue(); + delayed_dump_queue(); + continue; } + dbg("ipc message receive error '%s'", strerror(errno)); } } - return 0; -} - -static void sig_handler(int signum) -{ - dbg("caught signal %d", signum); - switch (signum) { - case SIGINT: - case SIGTERM: - case SIGKILL: - if (lock_file >= 0) { - close(lock_file); - unlink(lock_filename); - } - exit(20 + signum); - break; - - default: - dbg("unhandled signal"); - } } static int one_and_only(void) @@ -249,18 +313,17 @@ static int one_and_only(void) /* see if we can open */ if (lock_file < 0) - return -EINVAL; + return -1; /* see if we can lock */ if (lockf(lock_file, F_TLOCK, 0) < 0) { close(lock_file); - unlink(lock_filename); - return -EINVAL; + return -1; } snprintf(string, sizeof(string), "%d\n", getpid()); write(lock_file, string, strlen(string)); - + return 0; } @@ -273,12 +336,9 @@ int main(int argc, char *argv[]) /* set up signal handler */ signal(SIGINT, sig_handler); signal(SIGTERM, sig_handler); - signal(SIGKILL, sig_handler); + signal(SIGALRM, sig_handler); + signal(SIGCHLD, sig_handler); - /* we exit if we have nothing to do, next event will start us again */ - set_timer(DAEMON_TIMEOUT_SECONDS); - - /* main loop */ - process_queue(); - return 0; + work(); + exit(0); }