X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udevd.c;h=02c4887f541d304ff091ff4f6341570b042ac27b;hp=209b9fcd870074ed0db22e8c1a932e98b959f0a2;hb=c2e04d6b8b82e870c6b9ce397f5fdf9c8b4efb5a;hpb=972d318a3123b00d0ed6b78bbcf70a0965841a8e diff --git a/udevd.c b/udevd.c index 209b9fcd8..02c4887f5 100644 --- a/udevd.c +++ b/udevd.c @@ -1,5 +1,5 @@ /* - * udevd.c - hotplug event serializer + * udevd.c - event listener and serializer * * Copyright (C) 2004-2005 Kay Sievers * Copyright (C) 2004 Chris Friesen @@ -30,55 +30,44 @@ #include #include #include +#include +#include #include #include -#include #include #include #include -#include #include +#include +#include #include -#include "list.h" -#include "udev_libc_wrapper.h" #include "udev.h" -#include "udev_version.h" -#include "udev_utils.h" +#include "udev_rules.h" #include "udevd.h" -#include "logging.h" -/* global variables*/ +static struct udev_rules rules; static int udevd_sock; static int uevent_netlink_sock; +static int inotify_fd; static pid_t sid; -static int pipefds[2]; +static int signal_pipe[2] = {-1, -1}; static volatile int sigchilds_waiting; -static volatile int run_msg_q; -static volatile int sig_flag; -static int init_phase = 1; +static volatile int udev_exit; +static volatile int reload_config; static int run_exec_q; static int stop_exec_q; +static int max_childs; +static int max_childs_running; +static char udev_log[32]; -static LIST_HEAD(msg_list); static LIST_HEAD(exec_list); static LIST_HEAD(running_list); -static void exec_queue_manager(void); -static void msg_queue_manager(void); -static void user_sighandler(void); -static void reap_sigchilds(void); - -static char *udev_bin; -static unsigned long long expected_seqnum; -static int event_timeout; -static int max_childs; -static int max_childs_running; - #ifdef USE_LOG -void log_message (int priority, const char *format, ...) +void log_message(int priority, const char *format, ...) { va_list args; @@ -91,111 +80,236 @@ void log_message (int priority, const char *format, ...) } #endif -static void msg_dump_queue(void) +static void asmlinkage udev_event_sig_handler(int signum) { -#ifdef DEBUG - struct uevent_msg *msg; - - list_for_each_entry(msg, &msg_list, node) - dbg("sequence %llu in queue", msg->seqnum); -#endif + if (signum == SIGALRM) + exit(1); } -static void run_queue_delete(struct uevent_msg *msg) +static int udev_event_process(struct uevent_msg *msg) { - list_del(&msg->node); - free(msg); + struct sigaction act; + struct udevice *udev; + int i; + int retval; + + /* set signal handlers */ + memset(&act, 0x00, sizeof(act)); + act.sa_handler = (void (*)(int)) udev_event_sig_handler; + sigemptyset (&act.sa_mask); + act.sa_flags = 0; + sigaction(SIGALRM, &act, NULL); + + /* reset to default */ + act.sa_handler = SIG_DFL; + sigaction(SIGINT, &act, NULL); + sigaction(SIGTERM, &act, NULL); + sigaction(SIGCHLD, &act, NULL); + sigaction(SIGHUP, &act, NULL); + + /* trigger timeout to prevent hanging processes */ + alarm(UDEV_ALARM_TIMEOUT); + + /* reconstruct event environment from message */ + for (i = 0; msg->envp[i]; i++) + putenv(msg->envp[i]); + + udev = udev_device_init(); + if (udev == NULL) + return -1; + strlcpy(udev->action, msg->action, sizeof(udev->action)); + sysfs_device_set_values(udev->dev, msg->devpath, msg->subsystem); + udev->devt = msg->devt; + + retval = udev_device_event(&rules, udev); + + /* run programs collected by RUN-key*/ + if (retval == 0 && !udev->ignore_device && udev_run) { + struct name_entry *name_loop; + + dbg("executing run list"); + list_for_each_entry(name_loop, &udev->run_list, node) { + if (strncmp(name_loop->name, "socket:", strlen("socket:")) == 0) + pass_env_to_socket(&name_loop->name[strlen("socket:")], udev->dev->devpath, udev->action); + else { + char program[PATH_SIZE]; + + strlcpy(program, name_loop->name, sizeof(program)); + udev_rules_apply_format(udev, program, sizeof(program)); + if (run_program(program, udev->dev->subsystem, NULL, 0, NULL, + (udev_log_priority >= LOG_INFO))) + retval = -1; + } + } + } + + udev_device_cleanup(udev); + return retval; } -/* orders the message in the queue by sequence number */ -static void msg_queue_insert(struct uevent_msg *msg) +enum event_state { + EVENT_QUEUED, + EVENT_FINISHED, + EVENT_FAILED, +}; + +static void export_event_state(struct 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 sysinfo info; - if (msg->seqnum == 0) { - dbg("no SEQNUM, move straight to the exec queue"); - list_add(&msg->node, &exec_list); - run_exec_q = 1; + /* add location of queue files */ + strlcpy(filename, udev_root, sizeof(filename)); + strlcat(filename, "/", sizeof(filename)); + start = strlcat(filename, EVENT_QUEUE_DIR, sizeof(filename)); + end = strlcat(filename, msg->devpath, sizeof(filename)); + if (end > sizeof(filename)) + end = sizeof(filename); + + /* replace '/' to transform path into a filename */ + for (i = start+1; i < end; i++) + if (filename[i] == '/') + filename[i] = PATH_TO_NAME_CHAR; + + /* add location of failed files */ + strlcpy(filename_failed, udev_root, sizeof(filename_failed)); + strlcat(filename_failed, "/", sizeof(filename_failed)); + start = strlcat(filename_failed, EVENT_FAILED_DIR, sizeof(filename_failed)); + end = strlcat(filename_failed, msg->devpath, sizeof(filename_failed)); + if (end > sizeof(filename_failed)) + end = sizeof(filename_failed); + + /* replace '/' to transform path into a filename */ + for (i = start+1; i < end; i++) + if (filename_failed[i] == '/') + filename_failed[i] = PATH_TO_NAME_CHAR; + + switch (state) { + case EVENT_QUEUED: + unlink(filename_failed); + delete_path(filename_failed); + + strlcpy(target, sysfs_path, sizeof(target)); + strlcat(target, msg->devpath, sizeof(target)); + create_path(filename); + symlink(target, filename); return; - } + case EVENT_FINISHED: + case EVENT_FAILED: + unlink(filename_failed); + delete_path(filename_failed); + + /* don't remove, if events for the same path are still pending */ + list_for_each_entry(loop_msg, &running_list, node) + if (loop_msg->devpath && strcmp(loop_msg->devpath, msg->devpath) == 0) + return; - /* store timestamp of queuing */ - sysinfo(&info); - msg->queue_time = info.uptime; + list_for_each_entry(loop_msg, &exec_list, node) + if (loop_msg->devpath && strcmp(loop_msg->devpath, msg->devpath) == 0) + return; - /* with the first event we provide a phase of shorter timeout */ - if (init_phase) { - static long init_time; + /* move failed events to the failed directory */ + if (state == EVENT_FAILED) { + create_path(filename_failed); + rename(filename, filename_failed); + } else { + unlink(filename); + } - if (init_time == 0) - init_time = info.uptime; - if (info.uptime - init_time >= UDEVD_INIT_TIME) - init_phase = 0; - } + /* clean up the queue directory */ + delete_path(filename); - /* don't delay messages with timeout set */ - if (msg->timeout) { - dbg("move seq %llu with timeout %u to exec queue", msg->seqnum, msg->timeout); - list_add(&msg->node, &exec_list); - run_exec_q = 1; return; } +} - /* sort message by sequence number into list */ - list_for_each_entry_reverse(loop_msg, &msg_list, node) { - if (loop_msg->seqnum < msg->seqnum) - break; - - if (loop_msg->seqnum == msg->seqnum) { - dbg("ignoring duplicate message seq %llu", msg->seqnum); - free(msg); - return; - } - } - list_add(&msg->node, &loop_msg->node); - info("seq %llu queued, devpath '%s'", msg->seqnum, msg->devpath); +static void msg_queue_delete(struct uevent_msg *msg) +{ + list_del(&msg->node); - /* run msg queue manager */ - run_msg_q = 1; + /* mark as failed, if add event returns non-zero */ + if (msg->exitstatus && strcmp(msg->action, "add") == 0) + export_event_state(msg, EVENT_FAILED); + else + export_event_state(msg, EVENT_FINISHED); - return; + free(msg); } -/* forks event and removes event from run queue when finished */ -static void execute_udev(struct uevent_msg *msg) +static void udev_event_run(struct uevent_msg *msg) { - char *const argv[] = { "udev", msg->subsystem, NULL }; pid_t pid; - struct sysinfo info; + int retval; pid = fork(); switch (pid) { case 0: /* child */ - if (uevent_netlink_sock != -1) - close(uevent_netlink_sock); + close(uevent_netlink_sock); close(udevd_sock); + 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); - execve(udev_bin, argv, msg->envp); - err("exec of child failed"); - _exit(1); - break; + retval = udev_event_process(msg); + info("seq %llu finished", msg->seqnum); + + logging_close(); + if (retval) + exit(1); + exit(0); case -1: - err("fork of child failed"); - run_queue_delete(msg); + err("fork of child failed: %s", strerror(errno)); + msg_queue_delete(msg); break; default: /* get SIGCHLD in main loop */ - sysinfo(&info); - info("seq %llu forked, pid %d, %ld seconds old", - msg->seqnum, pid, info.uptime - msg->queue_time); + info("seq %llu forked, pid [%d], '%s' '%s', %ld seconds old", + msg->seqnum, pid, msg->action, msg->subsystem, time(NULL) - msg->queue_time); msg->pid = pid; } } +static void msg_queue_insert(struct uevent_msg *msg) +{ + char filename[PATH_SIZE]; + int fd; + + msg->queue_time = time(NULL); + + strlcpy(filename, udev_root, sizeof(filename)); + strlcat(filename, "/" EVENT_SEQNUM, sizeof(filename)); + fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644); + if (fd >= 0) { + char str[32]; + int len; + + len = sprintf(str, "%llu\n", msg->seqnum); + write(fd, str, len); + close(fd); + } + + export_event_state(msg, EVENT_QUEUED); + + /* run all events with a timeout set immediately */ + if (msg->timeout != 0) { + list_add_tail(&msg->node, &running_list); + udev_event_run(msg); + return; + } + + list_add_tail(&msg->node, &exec_list); + run_exec_q = 1; +} + +/* runs event and removes event from run queue when finished */ static int running_processes(void) { int f; @@ -208,7 +322,7 @@ static int running_processes(void) if (f == -1) return -1; - len = read(f, buf, sizeof(buf)); + len = read(f, buf, sizeof(buf)-1); close(f); if (len <= 0) @@ -257,7 +371,7 @@ static int running_processes_in_session(pid_t session, int limit) if (f == -1) continue; - len = read(f, line, sizeof(line)); + len = read(f, line, sizeof(line)-1); close(f); if (len <= 0) @@ -321,20 +435,11 @@ static int running_with_devpath(struct uevent_msg *msg, int limit) struct uevent_msg *loop_msg; int childs_count = 0; - if (msg->devpath == NULL) - return 0; - - /* skip any events with a timeout set */ - if (msg->timeout != 0) - return 0; - list_for_each_entry(loop_msg, &running_list, node) { if (limit && childs_count++ > limit) { dbg("%llu, maximum number (%i) of child reached", msg->seqnum, childs_count); return 1; } - if (loop_msg->devpath == NULL) - continue; /* return running parent/child device event */ if (compare_devpath(loop_msg->devpath, msg->devpath) != 0) { @@ -356,7 +461,7 @@ 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 exec_queue_manager(void) +static void msg_queue_manager(void) { struct uevent_msg *loop_msg; struct uevent_msg *tmp_msg; @@ -376,75 +481,22 @@ static void exec_queue_manager(void) running = running_processes_in_session(sid, max_childs_running+10); dbg("at least %d processes running in session", running); if (running >= max_childs_running) { - dbg("delay seq %llu, cause too many processes already running", - loop_msg->seqnum); + dbg("delay seq %llu, too many processes already running", loop_msg->seqnum); return; } } - if (running_with_devpath(loop_msg, max_childs) == 0) { - /* move event to run list */ - list_move_tail(&loop_msg->node, &running_list); - execute_udev(loop_msg); - running++; - dbg("moved seq %llu to running list", loop_msg->seqnum); - } else + /* don't run two processes for the same devpath and wait for the parent*/ + if (running_with_devpath(loop_msg, max_childs)) { dbg("delay seq %llu (%s)", loop_msg->seqnum, loop_msg->devpath); - } -} - -static void msg_move_exec(struct uevent_msg *msg) -{ - list_move_tail(&msg->node, &exec_list); - run_exec_q = 1; - expected_seqnum = msg->seqnum+1; - dbg("moved seq %llu to exec, next expected is %llu", - msg->seqnum, expected_seqnum); -} - -/* msg queue management routine handles the timeouts and dispatches the events */ -static void msg_queue_manager(void) -{ - struct uevent_msg *loop_msg; - struct uevent_msg *tmp_msg; - struct sysinfo info; - long msg_age = 0; - int timeout = event_timeout; - - dbg("msg queue manager, next expected is %llu", expected_seqnum); -recheck: - sysinfo(&info); - list_for_each_entry_safe(loop_msg, tmp_msg, &msg_list, node) { - /* move event with expected sequence to the exec list */ - if (loop_msg->seqnum == expected_seqnum) { - msg_move_exec(loop_msg); continue; } - /* limit timeout during initialization phase */ - if (init_phase) { - timeout = UDEVD_INIT_EVENT_TIMEOUT; - dbg("initialization phase, limit timeout to %i seconds", UDEVD_INIT_EVENT_TIMEOUT); - } - - /* move event with expired timeout to the exec list */ - msg_age = info.uptime - loop_msg->queue_time; - dbg("seq %llu is %li seconds old", loop_msg->seqnum, msg_age); - if (msg_age >= timeout) { - msg_move_exec(loop_msg); - goto recheck; - } else { - break; - } - } - - msg_dump_queue(); - - /* set timeout for remaining queued events */ - if (list_empty(&msg_list) == 0) { - struct itimerval itv = {{0, 0}, {timeout - msg_age, 0}}; - dbg("next event expires in %li seconds", timeout - msg_age); - setitimer(ITIMER_REAL, &itv, NULL); + /* move event to run list */ + list_move_tail(&loop_msg->node, &running_list); + udev_event_run(loop_msg); + running++; + dbg("moved seq %llu to running list", loop_msg->seqnum); } } @@ -453,6 +505,8 @@ static struct uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size) int bufpos; int i; struct uevent_msg *msg; + int major = 0; + int minor = 0; msg = malloc(sizeof(struct uevent_msg) + buf_size); if (msg == NULL) @@ -475,44 +529,47 @@ static struct uevent_msg *get_msg_from_envbuf(const char *buf, int buf_size) /* remember some keys for further processing */ if (strncmp(key, "ACTION=", 7) == 0) msg->action = &key[7]; - - if (strncmp(key, "DEVPATH=", 8) == 0) + else if (strncmp(key, "DEVPATH=", 8) == 0) msg->devpath = &key[8]; - - if (strncmp(key, "SUBSYSTEM=", 10) == 0) + else if (strncmp(key, "SUBSYSTEM=", 10) == 0) msg->subsystem = &key[10]; - - if (strncmp(key, "SEQNUM=", 7) == 0) + else if (strncmp(key, "SEQNUM=", 7) == 0) msg->seqnum = strtoull(&key[7], NULL, 10); - - if (strncmp(key, "PHYSDEVPATH=", 12) == 0) + else if (strncmp(key, "PHYSDEVPATH=", 12) == 0) msg->physdevpath = &key[12]; - - if (strncmp(key, "TIMEOUT=", 8) == 0) + else if (strncmp(key, "MAJOR=", 6) == 0) + major = strtoull(&key[6], NULL, 10); + else if (strncmp(key, "MINOR=", 6) == 0) + minor = strtoull(&key[6], NULL, 10); + else if (strncmp(key, "TIMEOUT=", 8) == 0) msg->timeout = strtoull(&key[8], NULL, 10); } + msg->devt = makedev(major, minor); msg->envp[i++] = "UDEVD_EVENT=1"; msg->envp[i] = NULL; + if (msg->devpath == NULL || msg->action == NULL) { + info("DEVPATH or ACTION missing, ignore message"); + free(msg); + return NULL; + } return msg; } /* receive the udevd message from userspace */ static struct uevent_msg *get_udevd_msg(void) { - static struct udevd_msg usend_msg; - struct uevent_msg *msg; + static struct udevd_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; + memset(&ctrl_msg, 0x00, sizeof(struct udevd_msg)); + iov.iov_base = &ctrl_msg; iov.iov_len = sizeof(struct udevd_msg); memset(&smsg, 0x00, sizeof(struct msghdr)); @@ -524,38 +581,28 @@ static struct uevent_msg *get_udevd_msg(void) size = recvmsg(udevd_sock, &smsg, 0); if (size < 0) { if (errno != EINTR) - dbg("unable to receive udevd message"); + err("unable to receive user udevd message: %s", strerror(errno)); return NULL; } cmsg = CMSG_FIRSTHDR(&smsg); cred = (struct ucred *) CMSG_DATA(cmsg); if (cmsg == NULL || cmsg->cmsg_type != SCM_CREDENTIALS) { - info("no sender credentials received, message ignored"); + err("no sender credentials received, message ignored"); return NULL; } if (cred->uid != 0) { - info("sender uid=%i, message ignored", cred->uid); + err("sender uid=%i, message ignored", cred->uid); return NULL; } - if (strncmp(usend_msg.magic, UDEV_MAGIC, sizeof(UDEV_MAGIC)) != 0 ) { - info("message magic '%s' doesn't match, ignore it", usend_msg.magic); + if (strncmp(ctrl_msg.magic, UDEV_MAGIC, sizeof(UDEV_MAGIC)) != 0 ) { + err("message magic '%s' doesn't match, ignore it", ctrl_msg.magic); return NULL; } - switch (usend_msg.type) { - case UDEVD_UEVENT_UDEVSEND: - case UDEVD_UEVENT_INITSEND: - 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; + switch (ctrl_msg.type) { case UDEVD_STOP_EXEC_QUEUE: info("udevd message (STOP_EXEC_QUEUE) received"); stop_exec_q = 1; @@ -563,18 +610,24 @@ static struct uevent_msg *get_udevd_msg(void) case UDEVD_START_EXEC_QUEUE: info("udevd message (START_EXEC_QUEUE) received"); stop_exec_q = 0; - exec_queue_manager(); + msg_queue_manager(); break; case UDEVD_SET_LOG_LEVEL: - intval = (int *) usend_msg.envbuf; + intval = (int *) ctrl_msg.envbuf; 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; + intval = (int *) ctrl_msg.envbuf; info("udevd message (UDEVD_SET_MAX_CHILDS) received, max_childs=%i", *intval); max_childs = *intval; break; + case UDEVD_RELOAD_RULES: + info("udevd message (RELOAD_RULES) received"); + reload_config = 1; + break; default: dbg("unknown message type"); } @@ -587,20 +640,20 @@ static struct uevent_msg *get_netlink_msg(void) struct uevent_msg *msg; int bufpos; ssize_t size; - static char buffer[UEVENT_BUFFER_SIZE + 512]; + static char buffer[UEVENT_BUFFER_SIZE+512]; char *pos; size = recv(uevent_netlink_sock, &buffer, sizeof(buffer), 0); if (size < 0) { if (errno != EINTR) - dbg("unable to receive udevd message"); + err("unable to receive kernel netlink message: %s", strerror(errno)); return NULL; } if ((size_t)size > sizeof(buffer)-1) size = sizeof(buffer)-1; buffer[size] = '\0'; - dbg("uevent_size=%i", size); + dbg("uevent_size=%zi", size); /* start of event payload */ bufpos = strlen(buffer)+1; @@ -612,20 +665,20 @@ static struct uevent_msg *get_netlink_msg(void) /* validate message */ pos = strchr(buffer, '@'); if (pos == NULL) { - dbg("invalid uevent '%s'", buffer); + err("invalid uevent '%s'", buffer); free(msg); return NULL; } pos[0] = '\0'; if (msg->action == NULL) { - dbg("no ACTION in payload found, skip event '%s'", buffer); + info("no ACTION in payload found, skip event '%s'", buffer); free(msg); return NULL; } if (strcmp(msg->action, buffer) != 0) { - dbg("ACTION in payload does not match uevent, skip event '%s'", buffer); + err("ACTION in payload does not match uevent, skip event '%s'", buffer); free(msg); return NULL; } @@ -635,52 +688,37 @@ static struct uevent_msg *get_netlink_msg(void) static void asmlinkage sig_handler(int signum) { - int rc; - switch (signum) { case SIGINT: case SIGTERM: - exit(20 + signum); - break; - case SIGALRM: - /* set flag, then write to pipe if needed */ - run_msg_q = 1; - goto do_write; + udev_exit = 1; break; case SIGCHLD: /* set flag, then write to pipe if needed */ sigchilds_waiting = 1; - goto do_write; + break; + case SIGHUP: + reload_config = 1; break; } -do_write: - /* if pipe is empty, write to pipe to force select to return - * immediately when it gets called - */ - if (!sig_flag) { - rc = write(pipefds[1],&signum,sizeof(signum)); - if (rc >= 0) - sig_flag = 1; - } + /* write to pipe, which will wakeup select() in our mainloop */ + write(signal_pipe[WRITE_END], "", 1); } -static void udev_done(int pid) +static void udev_done(int pid, int exitstatus) { /* find msg associated with pid and delete it */ struct uevent_msg *msg; - struct sysinfo info; list_for_each_entry(msg, &running_list, node) { if (msg->pid == pid) { - sysinfo(&info); - info("seq %llu exit, %ld seconds old", msg->seqnum, info.uptime - msg->queue_time); - run_queue_delete(msg); - - /* we want to run the exec queue manager since there may - * be events waiting with the devpath of the one that - * just finished - */ + info("seq %llu, pid [%d] exit with %i, %ld seconds old", msg->seqnum, msg->pid, + exitstatus, time(NULL) - msg->queue_time); + msg->exitstatus = exitstatus; + msg_queue_delete(msg); + + /* there may be events waiting with the same devpath */ run_exec_q = 1; return; } @@ -689,33 +727,27 @@ static void udev_done(int pid) static void reap_sigchilds(void) { - while(1) { - int pid = waitpid(-1, NULL, WNOHANG); - if ((pid == -1) || (pid == 0)) - break; - udev_done(pid); - } -} - -/* just read everything from the pipe and clear the flag, - * the flags was set in the signal handler - */ -static void user_sighandler(void) -{ - int sig; + pid_t pid; + int status; - while(1) { - int rc = read(pipefds[0], &sig, sizeof(sig)); - if (rc < 0) + while (1) { + pid = waitpid(-1, &status, WNOHANG); + if (pid <= 0) break; - - sig_flag = 0; + if (WIFEXITED(status)) + status = WEXITSTATUS(status); + else if (WIFSIGNALED(status)) + status = WTERMSIG(status) + 128; + else + status = 0; + udev_done(pid, status); } } 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; @@ -728,15 +760,17 @@ static int init_udevd_socket(void) udevd_sock = socket(AF_LOCAL, SOCK_DGRAM, 0); if (udevd_sock == -1) { - err("error getting socket, %s", strerror(errno)); + err("error getting socket: %s", strerror(errno)); 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); + err("bind failed: %s", strerror(errno)); return -1; } @@ -749,6 +783,7 @@ static int init_udevd_socket(void) static int init_uevent_netlink_sock(void) { struct sockaddr_nl snl; + const int buffersize = 16 * 1024 * 1024; int retval; memset(&snl, 0x00, sizeof(struct sockaddr_nl)); @@ -758,36 +793,81 @@ static int init_uevent_netlink_sock(void) uevent_netlink_sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT); if (uevent_netlink_sock == -1) { - dbg("error getting socket, %s", strerror(errno)); + err("error getting socket: %s", strerror(errno)); return -1; } - retval = bind(uevent_netlink_sock, (struct sockaddr *) &snl, - sizeof(struct sockaddr_nl)); + /* set receive buffersize */ + setsockopt(uevent_netlink_sock, SOL_SOCKET, SO_RCVBUFFORCE, &buffersize, sizeof(buffersize)); + + retval = bind(uevent_netlink_sock, (struct sockaddr *) &snl, sizeof(struct sockaddr_nl)); if (retval < 0) { - dbg("bind failed, %s", strerror(errno)); + err("bind failed: %s", strerror(errno)); close(uevent_netlink_sock); uevent_netlink_sock = -1; return -1; } - return 0; } +static void export_initial_seqnum(void) +{ + char filename[PATH_SIZE]; + int fd; + char seqnum[32]; + ssize_t len = 0; + + strlcpy(filename, sysfs_path, sizeof(filename)); + strlcat(filename, "/kernel/uevent_seqnum", sizeof(filename)); + fd = open(filename, O_RDONLY); + if (fd >= 0) { + len = read(fd, seqnum, sizeof(seqnum)-1); + close(fd); + } + if (len <= 0) { + strcpy(seqnum, "0\n"); + len = 3; + } + 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); + close(fd); + } +} + int main(int argc, char *argv[], char *envp[]) { - int maxsockplus; int retval; int fd; struct sigaction act; fd_set readfds; const char *value; - int uevent_netlink_active = 0; int daemonize = 0; int i; + int rc = 0; + int maxfd; + + /* redirect std fd's, if the kernel forks us, we don't have them at all */ + fd = open("/dev/null", O_RDWR); + if (fd >= 0) { + if (fd != STDIN_FILENO) + dup2(fd, STDIN_FILENO); + if (fd != STDOUT_FILENO) + dup2(fd, STDOUT_FILENO); + if (fd != STDERR_FILENO) + dup2(fd, STDERR_FILENO); + if (fd > STDERR_FILENO) + close(fd); + } logging_init("udevd"); - udev_init_config(); + if (fd < 0) + err("fatal, could not open /dev/null: %s", strerror(errno)); + + udev_config_init(); dbg("version %s", UDEV_VERSION); if (getuid() != 0) { @@ -795,6 +875,7 @@ int main(int argc, char *argv[], char *envp[]) goto exit; } + /* parse commandline options */ for (i = 1 ; i < argc; i++) { char *arg = argv[i]; if (strcmp(arg, "--daemon") == 0 || strcmp(arg, "-d") == 0) { @@ -806,68 +887,96 @@ int main(int argc, char *argv[], char *envp[]) stop_exec_q = 1; } } + + /* init sockets to receive events */ + if (init_udevd_socket() < 0) { + if (errno == EADDRINUSE) { + err("another udevd running, exit"); + rc = 1; + } else { + err("error initializing udevd socket: %s", strerror(errno)); + rc = 2; + } + goto exit; + } + + if (init_uevent_netlink_sock() < 0) { + err("uevent socket not available"); + rc = 3; + goto exit; + } + + /* parse the rules and keep it in memory */ + sysfs_init(); + udev_rules_init(&rules, 1); + + export_initial_seqnum(); + if (daemonize) { pid_t pid; pid = fork(); switch (pid) { case 0: - dbg("damonized fork running"); + dbg("daemonized fork running"); break; case -1: - err("fork of daemon failed"); + err("fork of daemon failed: %s", strerror(errno)); + rc = 4; goto exit; default: - logging_close(); - exit(0); + dbg("child [%u] running, parent exits", pid); + goto exit; } } - /* become session leader */ - sid = setsid(); - dbg("our session is %d", sid); + /* set scheduling priority for the daemon */ + setpriority(PRIO_PROCESS, 0, UDEVD_PRIORITY); chdir("/"); - umask(umask(077) | 022); + umask(022); - /*set a reasonable scheduling priority for the daemon */ - setpriority(PRIO_PROCESS, 0, UDEVD_PRIORITY); + /* become session leader */ + sid = setsid(); + dbg("our session is %d", sid); - /* Set fds to dev/null */ - fd = open( "/dev/null", O_RDWR ); - if (fd >= 0) { - dup2(fd, 0); - dup2(fd, 1); - dup2(fd, 2); - if (fd > 2) - close(fd); - } else - err("error opening /dev/null %s", strerror(errno)); + /* OOM_DISABLE == -17 */ + fd = open("/proc/self/oom_adj", O_RDWR); + if (fd < 0) + err("error disabling OOM: %s", strerror(errno)); + else { + write(fd, "-17", 3); + close(fd); + } /* setup signal handler pipe */ - retval = pipe(pipefds); + retval = pipe(signal_pipe); if (retval < 0) { err("error getting pipes: %s", strerror(errno)); goto exit; } - retval = fcntl(pipefds[0], F_SETFL, O_NONBLOCK); + retval = fcntl(signal_pipe[READ_END], F_GETFL, 0); if (retval < 0) { err("error fcntl on read pipe: %s", strerror(errno)); goto exit; } - retval = fcntl(pipefds[0], F_SETFD, FD_CLOEXEC); - if (retval < 0) + retval = fcntl(signal_pipe[READ_END], F_SETFL, retval | O_NONBLOCK); + if (retval < 0) { err("error fcntl on read pipe: %s", strerror(errno)); + goto exit; + } - retval = fcntl(pipefds[1], F_SETFL, O_NONBLOCK); + retval = fcntl(signal_pipe[WRITE_END], F_GETFL, 0); if (retval < 0) { err("error fcntl on write pipe: %s", strerror(errno)); goto exit; } - retval = fcntl(pipefds[1], F_SETFD, FD_CLOEXEC); - if (retval < 0) + retval = fcntl(signal_pipe[WRITE_END], F_SETFL, retval | O_NONBLOCK); + if (retval < 0) { err("error fcntl on write pipe: %s", strerror(errno)); + goto exit; + } /* set signal handlers */ memset(&act, 0x00, sizeof(struct sigaction)); @@ -876,43 +985,17 @@ int main(int argc, char *argv[], char *envp[]) act.sa_flags = SA_RESTART; sigaction(SIGINT, &act, NULL); sigaction(SIGTERM, &act, NULL); - sigaction(SIGALRM, &act, NULL); sigaction(SIGCHLD, &act, NULL); - - if (init_uevent_netlink_sock() < 0) { - dbg("uevent socket not available"); - } - - if (init_udevd_socket() < 0) { - if (errno == EADDRINUSE) - dbg("another udevd running, exit"); - else - dbg("error initialising udevd socket: %s", strerror(errno)); - - goto exit; - } - - /* override of forked udev binary, used for testing */ - udev_bin = getenv("UDEV_BIN"); - if (udev_bin != NULL) - info("udev binary is set to '%s'", udev_bin); + sigaction(SIGHUP, &act, NULL); + + /* watch rules directory */ + inotify_fd = inotify_init(); + if (inotify_fd >= 0) + inotify_add_watch(inotify_fd, udev_rules_filename, IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE); + else if (errno == ENOSYS) + err("the kernel does not support inotify, udevd can't monitor configuration file changes"); else - udev_bin = UDEV_BIN; - - /* init of expected_seqnum value */ - value = getenv("UDEVD_EXPECTED_SEQNUM"); - if (value) { - expected_seqnum = strtoull(value, NULL, 10); - info("initialize expected_seqnum to %llu", expected_seqnum); - } - - /* timeout to wait for missing events */ - value = getenv("UDEVD_EVENT_TIMEOUT"); - if (value) - event_timeout = strtoul(value, NULL, 10); - else - event_timeout = UDEVD_EVENT_TIMEOUT; - info("initialize event_timeout to %u", event_timeout); + err("inotify_init failed: %s", strerror(errno)); /* maximum limit of forked childs */ value = getenv("UDEVD_MAX_CHILDS"); @@ -930,76 +1013,114 @@ int main(int argc, char *argv[], char *envp[]) max_childs_running = UDEVD_MAX_CHILDS_RUNNING; info("initialize max_childs_running to %u", max_childs_running); - FD_ZERO(&readfds); - FD_SET(udevd_sock, &readfds); - if (uevent_netlink_sock != -1) - FD_SET(uevent_netlink_sock, &readfds); - FD_SET(pipefds[0], &readfds); - maxsockplus = udevd_sock+1; - while (1) { + /* clear environment for forked event processes */ + clearenv(); + + /* export log_priority , as called programs may want to follow that setting */ + sprintf(udev_log, "UDEV_LOG=%i", udev_log_priority); + putenv(udev_log); + + maxfd = udevd_sock; + maxfd = UDEV_MAX(maxfd, uevent_netlink_sock); + maxfd = UDEV_MAX(maxfd, signal_pipe[READ_END]); + maxfd = UDEV_MAX(maxfd, inotify_fd); + + while (!udev_exit) { struct uevent_msg *msg; + int fdcount; - fd_set workreadfds = readfds; - retval = select(maxsockplus, &workreadfds, NULL, NULL, NULL); + FD_ZERO(&readfds); + FD_SET(signal_pipe[READ_END], &readfds); + FD_SET(udevd_sock, &readfds); + FD_SET(uevent_netlink_sock, &readfds); + if (inotify_fd >= 0) + FD_SET(inotify_fd, &readfds); - if (retval < 0) { + fdcount = select(maxfd+1, &readfds, NULL, NULL, NULL); + if (fdcount < 0) { if (errno != EINTR) - dbg("error in select: %s", strerror(errno)); + err("error in select: %s", strerror(errno)); continue; } - if (FD_ISSET(udevd_sock, &workreadfds)) { + /* get user socket message */ + if (FD_ISSET(udevd_sock, &readfds)) { msg = get_udevd_msg(); - if (msg) { - /* discard kernel messages if netlink is active */ - if (uevent_netlink_active && msg->type == UDEVD_UEVENT_UDEVSEND && msg->seqnum != 0) { - dbg("skip uevent_helper message, netlink is active"); - free(msg); - continue; - } + if (msg) msg_queue_insert(msg); - } } - if (FD_ISSET(uevent_netlink_sock, &workreadfds)) { + /* get kernel netlink message */ + if (FD_ISSET(uevent_netlink_sock, &readfds)) { msg = get_netlink_msg(); - if (msg) { + if (msg) msg_queue_insert(msg); - /* disable udevsend with first netlink message */ - if (!uevent_netlink_active) { - info("uevent_nl message received, disable udevsend messages"); - uevent_netlink_active = 1; + } + + /* 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)) { + int nbytes; + + /* discard all possible events, we can just reload the config */ + if ((ioctl(inotify_fd, FIONREAD, &nbytes) == 0) && nbytes) { + char *buf; + + reload_config = 1; + buf = malloc(nbytes); + if (!buf) { + err("error getting buffer for inotify, disable watching"); + close(inotify_fd); + inotify_fd = -1; } + read(inotify_fd, buf, nbytes); + free(buf); } } - if (FD_ISSET(pipefds[0], &workreadfds)) - user_sighandler(); + /* rules changed, set by inotify or a signal*/ + if (reload_config) { + reload_config = 0; + udev_rules_cleanup(&rules); + udev_rules_init(&rules, 1); + } + /* forked child has returned */ if (sigchilds_waiting) { sigchilds_waiting = 0; reap_sigchilds(); } - if (run_msg_q) { - run_msg_q = 0; - msg_queue_manager(); - } - if (run_exec_q) { - /* clean up running_list before calling exec_queue_manager() */ - if (sigchilds_waiting) { - sigchilds_waiting = 0; - reap_sigchilds(); - } - run_exec_q = 0; if (!stop_exec_q) - exec_queue_manager(); + msg_queue_manager(); } } exit: + udev_rules_cleanup(&rules); + sysfs_cleanup(); + + if (signal_pipe[READ_END] >= 0) + close(signal_pipe[READ_END]); + if (signal_pipe[WRITE_END] >= 0) + close(signal_pipe[WRITE_END]); + + if (udevd_sock >= 0) + close(udevd_sock); + if (inotify_fd >= 0) + close(inotify_fd); + if (uevent_netlink_sock >= 0) + close(uevent_netlink_sock); + logging_close(); - return 1; + + return rc; }