#include "list.h"
#include "udev.h"
+#include "udev_version.h"
#include "udevd.h"
#include "logging.h"
+
#define BUFFER_SIZE 1024
+static int running_remove_queue(pid_t pid);
+static int msg_exec(struct hotplug_msg *msg);
+
static int expect_seqnum = 0;
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_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:
- case SIGKILL:
if (lock_file >= 0) {
close(lock_file);
unlink(lock_filename);
}
}
-static void dump_queue(void)
+static void set_timeout(int seconds)
{
- struct hotplug_msg *msg;
+ alarm(seconds);
+ dbg("set timeout in %d seconds", seconds);
+}
- list_for_each_entry(msg, &msg_list, list)
- dbg("sequence %d in queue", msg->seqnum);
+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 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 dump_msg(struct hotplug_msg *msg)
+static void msg_dump(struct hotplug_msg *msg)
{
dbg("sequence %d, '%s', '%s', '%s'",
msg->seqnum, msg->action, msg->devpath, msg->subsystem);
}
-static int dispatch_msg(struct hotplug_msg *msg)
+static int msg_exec(struct hotplug_msg *msg)
{
pid_t pid;
- dump_msg(msg);
+ msg_dump(msg);
setenv("ACTION", msg->action, 1);
setenv("DEVPATH", msg->devpath, 1);
+ /* 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 */
- execl(UDEV_EXEC, "udev", msg->subsystem, NULL);
+ execl(UDEV_BIN, "udev", msg->subsystem, NULL);
dbg("exec of child failed");
exit(1);
break;
dbg("fork of child failed");
return -1;
default:
- wait(NULL);
+ /* exec in background, get the SIGCHLD with the sig handler */
+ msg->pid = pid;
+ running_moveto_queue(msg);
+ break;
}
return 0;
}
-static void set_timeout(int seconds)
+static void msg_dump_queue(void)
{
- alarm(seconds);
- dbg("set timeout in %d seconds", 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 *msg;
struct hotplug_msg *tmp_msg;
list_for_each_entry_safe(msg, tmp_msg, &msg_list, list) {
if (msg->seqnum != expect_seqnum)
break;
- dispatch_msg(msg);
+ msg_exec(msg);
expect_seqnum++;
- list_del_init(&msg->list);
- free(msg);
}
- /* recalculate timeout */
+ /* recalculate next timeout */
if (list_empty(&msg_list) == 0) {
msg_age = time(NULL) - msg->queue_time;
- if (msg_age > EVENT_TIMEOUT_SECONDS-1) {
+ 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;
}
- set_timeout(EVENT_TIMEOUT_SECONDS - msg_age);
+
+ /* 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;
}
-
- /* queue is empty */
- set_timeout(UDEVD_TIMEOUT_SECONDS);
}
-static int queue_msg(struct hotplug_msg *msg)
+static int msg_add_queue(struct hotplug_msg *msg)
{
struct hotplug_msg *new_msg;
struct hotplug_msg *tmp_msg;
char buf[BUFFER_SIZE];
int ret;
- key = ftok(UDEVD_EXEC, IPC_KEY_ID);
+ key = ftok(UDEVD_BIN, IPC_KEY_ID);
msg = (struct hotplug_msg *) buf;
msgid = msgget(key, IPC_CREAT);
if (msgid == -1) {
while (1) {
ret = msgrcv(msgid, (struct msgbuf *) buf, BUFFER_SIZE-4, HOTPLUGMSGTYPE, 0);
if (ret != -1) {
- /* init the expected sequence with value from first call */
- if (expect_seqnum == 0) {
- expect_seqnum = msg->seqnum;
- dbg("init next expected sequence number to %d", expect_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();
+ 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;
}
- if (msg->seqnum > expect_seqnum) {
- /* something missing, queue event*/
- queue_msg(msg);
- check_queue();
- dump_queue();
- continue;
- }
- dbg("too late for event with sequence %d, even skipped ", msg->seqnum);
+ dbg("too late for event with sequence %d, event skipped ", msg->seqnum);
} else {
if (errno == EINTR) {
- /* 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();
- dump_queue();
+ msg_check_queue();
+ msg_dump_queue();
+ delayed_check_queue();
+ delayed_dump_queue();
continue;
}
dbg("ipc message receive error '%s'", strerror(errno));
/* set up signal handler */
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
- signal(SIGKILL, sig_handler);
signal(SIGALRM, sig_handler);
-
- /* we exit if we have nothing to do, next event will start us again */
- set_timeout(UDEVD_TIMEOUT_SECONDS);
+ signal(SIGCHLD, sig_handler);
work();
exit(0);
~ianmdlvl / elogind.git / blobdiff