diff options
Diffstat (limited to 'src/udev/udev-event.c')
-rw-r--r-- | src/udev/udev-event.c | 1066 |
1 files changed, 505 insertions, 561 deletions
diff --git a/src/udev/udev-event.c b/src/udev/udev-event.c index fd8406d959..e28d6a5d08 100644 --- a/src/udev/udev-event.c +++ b/src/udev/udev-event.c @@ -1,68 +1,85 @@ /* SPDX-License-Identifier: GPL-2.0+ */ -/* - * - */ #include <ctype.h> #include <errno.h> #include <fcntl.h> #include <net/if.h> -#include <poll.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h> -#include <string.h> -#include <sys/epoll.h> -#include <sys/prctl.h> -#include <sys/signalfd.h> -#include <sys/wait.h> #include <unistd.h> +#include "sd-event.h" + #include "alloc-util.h" +#include "device-private.h" +#include "device-util.h" #include "fd-util.h" #include "format-util.h" +#include "libudev-util.h" #include "netlink-util.h" +#include "path-util.h" #include "process-util.h" +#include "rlimit-util.h" #include "signal-util.h" +#include "stdio-util.h" #include "string-util.h" +#include "strv.h" +#include "strxcpyx.h" +#include "udev-builtin.h" +#include "udev-node.h" +#include "udev-watch.h" #include "udev.h" typedef struct Spawn { const char *cmd; pid_t pid; - usec_t timeout_warn; - usec_t timeout; + usec_t timeout_warn_usec; + usec_t timeout_usec; + usec_t event_birth_usec; bool accept_failure; + int fd_stdout; + int fd_stderr; + char *result; + size_t result_size; + size_t result_len; } Spawn; -struct udev_event *udev_event_new(struct udev_device *dev) { - struct udev *udev = udev_device_get_udev(dev); - struct udev_event *event; +UdevEvent *udev_event_new(sd_device *dev, usec_t exec_delay_usec, sd_netlink *rtnl) { + UdevEvent *event; + + assert(dev); - event = new0(struct udev_event, 1); - if (event == NULL) + event = new(UdevEvent, 1); + if (!event) return NULL; - event->dev = dev; - event->udev = udev; - udev_list_init(udev, &event->run_list, false); - udev_list_init(udev, &event->seclabel_list, false); - event->birth_usec = now(CLOCK_MONOTONIC); + + *event = (UdevEvent) { + .dev = sd_device_ref(dev), + .birth_usec = now(CLOCK_MONOTONIC), + .exec_delay_usec = exec_delay_usec, + .rtnl = sd_netlink_ref(rtnl), + }; + return event; } -void udev_event_unref(struct udev_event *event) { - if (event == NULL) - return; +UdevEvent *udev_event_free(UdevEvent *event) { + if (!event) + return NULL; + + sd_device_unref(event->dev); + sd_device_unref(event->dev_db_clone); sd_netlink_unref(event->rtnl); - udev_list_cleanup(&event->run_list); - udev_list_cleanup(&event->seclabel_list); + hashmap_free_free_key(event->run_list); + hashmap_free_free_free(event->seclabel_list); free(event->program_result); free(event->name); - free(event); + + return mfree(event); } enum subst_type { - SUBST_UNKNOWN, SUBST_DEVNODE, SUBST_ATTR, SUBST_ENV, @@ -81,68 +98,103 @@ enum subst_type { SUBST_SYS, }; -static size_t subst_format_var(struct udev_event *event, struct udev_device *dev, - enum subst_type type, char *attr, - char *dest, size_t l) { +struct subst_map_entry { + const char *name; + const char fmt; + enum subst_type type; +}; + +static const struct subst_map_entry map[] = { + { .name = "devnode", .fmt = 'N', .type = SUBST_DEVNODE }, + { .name = "tempnode", .fmt = 'N', .type = SUBST_DEVNODE }, + { .name = "attr", .fmt = 's', .type = SUBST_ATTR }, + { .name = "sysfs", .fmt = 's', .type = SUBST_ATTR }, + { .name = "env", .fmt = 'E', .type = SUBST_ENV }, + { .name = "kernel", .fmt = 'k', .type = SUBST_KERNEL }, + { .name = "number", .fmt = 'n', .type = SUBST_KERNEL_NUMBER }, + { .name = "driver", .fmt = 'd', .type = SUBST_DRIVER }, + { .name = "devpath", .fmt = 'p', .type = SUBST_DEVPATH }, + { .name = "id", .fmt = 'b', .type = SUBST_ID }, + { .name = "major", .fmt = 'M', .type = SUBST_MAJOR }, + { .name = "minor", .fmt = 'm', .type = SUBST_MINOR }, + { .name = "result", .fmt = 'c', .type = SUBST_RESULT }, + { .name = "parent", .fmt = 'P', .type = SUBST_PARENT }, + { .name = "name", .fmt = 'D', .type = SUBST_NAME }, + { .name = "links", .fmt = 'L', .type = SUBST_LINKS }, + { .name = "root", .fmt = 'r', .type = SUBST_ROOT }, + { .name = "sys", .fmt = 'S', .type = SUBST_SYS }, +}; + +static ssize_t subst_format_var(UdevEvent *event, + const struct subst_map_entry *entry, char *attr, + char *dest, size_t l) { + sd_device *parent, *dev = event->dev; + const char *val = NULL; char *s = dest; + dev_t devnum; + int r; + + assert(entry); - switch (type) { + switch (entry->type) { case SUBST_DEVPATH: - l = strpcpy(&s, l, udev_device_get_devpath(dev)); + r = sd_device_get_devpath(dev, &val); + if (r < 0) + return r; + l = strpcpy(&s, l, val); break; case SUBST_KERNEL: - l = strpcpy(&s, l, udev_device_get_sysname(dev)); + r = sd_device_get_sysname(dev, &val); + if (r < 0) + return r; + l = strpcpy(&s, l, val); break; case SUBST_KERNEL_NUMBER: - if (udev_device_get_sysnum(dev) == NULL) - break; - l = strpcpy(&s, l, udev_device_get_sysnum(dev)); + r = sd_device_get_sysnum(dev, &val); + if (r < 0) + return r == -ENOENT ? 0 : r; + l = strpcpy(&s, l, val); break; case SUBST_ID: - if (event->dev_parent == NULL) - break; - l = strpcpy(&s, l, udev_device_get_sysname(event->dev_parent)); - break; - case SUBST_DRIVER: { - const char *driver; - - if (event->dev_parent == NULL) - break; - - driver = udev_device_get_driver(event->dev_parent); - if (driver == NULL) - break; - l = strpcpy(&s, l, driver); + if (!event->dev_parent) + return 0; + r = sd_device_get_sysname(event->dev_parent, &val); + if (r < 0) + return r; + l = strpcpy(&s, l, val); break; - } - case SUBST_MAJOR: { - char num[UTIL_PATH_SIZE]; - - sprintf(num, "%u", major(udev_device_get_devnum(dev))); - l = strpcpy(&s, l, num); + case SUBST_DRIVER: + if (!event->dev_parent) + return 0; + r = sd_device_get_driver(event->dev_parent, &val); + if (r < 0) + return r == -ENOENT ? 0 : r; + l = strpcpy(&s, l, val); break; - } + case SUBST_MAJOR: case SUBST_MINOR: { - char num[UTIL_PATH_SIZE]; + char buf[DECIMAL_STR_MAX(unsigned)]; - sprintf(num, "%u", minor(udev_device_get_devnum(dev))); - l = strpcpy(&s, l, num); + r = sd_device_get_devnum(dev, &devnum); + if (r < 0 && r != -ENOENT) + return r; + xsprintf(buf, "%u", r < 0 ? 0 : entry->type == SUBST_MAJOR ? major(devnum) : minor(devnum)); + l = strpcpy(&s, l, buf); break; } case SUBST_RESULT: { char *rest; int i; - if (event->program_result == NULL) - break; + if (!event->program_result) + return 0; + /* get part of the result string */ i = 0; - if (attr != NULL) + if (attr) i = strtoul(attr, &rest, 10); if (i > 0) { - char result[UTIL_PATH_SIZE]; - char tmp[UTIL_PATH_SIZE]; - char *cpos; + char result[UTIL_PATH_SIZE], tmp[UTIL_PATH_SIZE], *cpos; strscpy(result, sizeof(result), event->program_result); cpos = result; @@ -166,88 +218,79 @@ static size_t subst_format_var(struct udev_event *event, struct udev_device *dev cpos[0] = '\0'; } l = strpcpy(&s, l, tmp); - } else { + } else l = strpcpy(&s, l, event->program_result); - } break; } case SUBST_ATTR: { - const char *value = NULL; char vbuf[UTIL_NAME_SIZE]; size_t len; int count; - if (attr == NULL) { - log_error("missing file parameter for attr"); - break; - } + if (!attr) + return -EINVAL; /* try to read the value specified by "[dmi/id]product_name" */ - if (util_resolve_subsys_kernel(event->udev, attr, vbuf, sizeof(vbuf), 1) == 0) - value = vbuf; + if (util_resolve_subsys_kernel(attr, vbuf, sizeof(vbuf), true) == 0) + val = vbuf; /* try to read the attribute the device */ - if (value == NULL) - value = udev_device_get_sysattr_value(event->dev, attr); + if (!val) + (void) sd_device_get_sysattr_value(dev, attr, &val); /* try to read the attribute of the parent device, other matches have selected */ - if (value == NULL && event->dev_parent != NULL && event->dev_parent != event->dev) - value = udev_device_get_sysattr_value(event->dev_parent, attr); + if (!val && event->dev_parent && event->dev_parent != dev) + (void) sd_device_get_sysattr_value(event->dev_parent, attr, &val); - if (value == NULL) - break; + if (!val) + return 0; /* strip trailing whitespace, and replace unwanted characters */ - if (value != vbuf) - strscpy(vbuf, sizeof(vbuf), value); + if (val != vbuf) + strscpy(vbuf, sizeof(vbuf), val); len = strlen(vbuf); while (len > 0 && isspace(vbuf[--len])) vbuf[len] = '\0'; count = util_replace_chars(vbuf, UDEV_ALLOWED_CHARS_INPUT); if (count > 0) - log_debug("%i character(s) replaced" , count); + log_device_debug(dev, "%i character(s) replaced", count); l = strpcpy(&s, l, vbuf); break; } - case SUBST_PARENT: { - struct udev_device *dev_parent; - const char *devnode; - - dev_parent = udev_device_get_parent(event->dev); - if (dev_parent == NULL) - break; - devnode = udev_device_get_devnode(dev_parent); - if (devnode != NULL) - l = strpcpy(&s, l, devnode + STRLEN("/dev/")); + case SUBST_PARENT: + r = sd_device_get_parent(dev, &parent); + if (r < 0) + return r == -ENODEV ? 0 : r; + r = sd_device_get_devname(parent, &val); + if (r < 0) + return r == -ENOENT ? 0 : r; + l = strpcpy(&s, l, val + STRLEN("/dev/")); break; - } case SUBST_DEVNODE: - if (udev_device_get_devnode(dev) != NULL) - l = strpcpy(&s, l, udev_device_get_devnode(dev)); + r = sd_device_get_devname(dev, &val); + if (r < 0) + return r == -ENOENT ? 0 : r; + l = strpcpy(&s, l, val); break; case SUBST_NAME: - if (event->name != NULL) + if (event->name) l = strpcpy(&s, l, event->name); - else if (udev_device_get_devnode(dev) != NULL) - l = strpcpy(&s, l, - udev_device_get_devnode(dev) + STRLEN("/dev/")); - else - l = strpcpy(&s, l, udev_device_get_sysname(dev)); + else if (sd_device_get_devname(dev, &val) >= 0) + l = strpcpy(&s, l, val + STRLEN("/dev/")); + else { + r = sd_device_get_sysname(dev, &val); + if (r < 0) + return r; + l = strpcpy(&s, l, val); + } break; - case SUBST_LINKS: { - struct udev_list_entry *list_entry; - - list_entry = udev_device_get_devlinks_list_entry(dev); - if (list_entry == NULL) - break; - l = strpcpy(&s, l, - udev_list_entry_get_name(list_entry) + STRLEN("/dev/")); - udev_list_entry_foreach(list_entry, udev_list_entry_get_next(list_entry)) - l = strpcpyl(&s, l, " ", - udev_list_entry_get_name(list_entry) + STRLEN("/dev/"), - NULL); + case SUBST_LINKS: + FOREACH_DEVICE_DEVLINK(dev, val) + if (s == dest) + l = strpcpy(&s, l, val + STRLEN("/dev/")); + else + l = strpcpyl(&s, l, " ", val + STRLEN("/dev/"), NULL); break; - } case SUBST_ROOT: l = strpcpy(&s, l, "/dev"); break; @@ -255,73 +298,47 @@ static size_t subst_format_var(struct udev_event *event, struct udev_device *dev l = strpcpy(&s, l, "/sys"); break; case SUBST_ENV: - if (attr == NULL) { - break; - } else { - const char *value; - - value = udev_device_get_property_value(event->dev, attr); - if (value == NULL) - break; - l = strpcpy(&s, l, value); - break; - } - default: - log_error("unknown substitution type=%i", type); + if (!attr) + return 0; + r = sd_device_get_property_value(dev, attr, &val); + if (r < 0) + return r == -ENOENT ? 0 : r; + l = strpcpy(&s, l, val); break; + default: + assert_not_reached("Unknown format substitution type"); } return s - dest; } -size_t udev_event_apply_format(struct udev_event *event, - const char *src, char *dest, size_t size, - bool replace_whitespace) { - struct udev_device *dev = event->dev; - static const struct subst_map { - const char *name; - const char fmt; - enum subst_type type; - } map[] = { - { .name = "devnode", .fmt = 'N', .type = SUBST_DEVNODE }, - { .name = "tempnode", .fmt = 'N', .type = SUBST_DEVNODE }, - { .name = "attr", .fmt = 's', .type = SUBST_ATTR }, - { .name = "sysfs", .fmt = 's', .type = SUBST_ATTR }, - { .name = "env", .fmt = 'E', .type = SUBST_ENV }, - { .name = "kernel", .fmt = 'k', .type = SUBST_KERNEL }, - { .name = "number", .fmt = 'n', .type = SUBST_KERNEL_NUMBER }, - { .name = "driver", .fmt = 'd', .type = SUBST_DRIVER }, - { .name = "devpath", .fmt = 'p', .type = SUBST_DEVPATH }, - { .name = "id", .fmt = 'b', .type = SUBST_ID }, - { .name = "major", .fmt = 'M', .type = SUBST_MAJOR }, - { .name = "minor", .fmt = 'm', .type = SUBST_MINOR }, - { .name = "result", .fmt = 'c', .type = SUBST_RESULT }, - { .name = "parent", .fmt = 'P', .type = SUBST_PARENT }, - { .name = "name", .fmt = 'D', .type = SUBST_NAME }, - { .name = "links", .fmt = 'L', .type = SUBST_LINKS }, - { .name = "root", .fmt = 'r', .type = SUBST_ROOT }, - { .name = "sys", .fmt = 'S', .type = SUBST_SYS }, - }; +ssize_t udev_event_apply_format(UdevEvent *event, + const char *src, char *dest, size_t size, + bool replace_whitespace) { const char *from; char *s; size_t l; - assert(dev); + assert(event); + assert(event->dev); + assert(src); + assert(dest); + assert(size > 0); from = src; s = dest; l = size; for (;;) { - enum subst_type type = SUBST_UNKNOWN; - char attrbuf[UTIL_PATH_SIZE]; - char *attr = NULL; - size_t subst_len; + const struct subst_map_entry *entry = NULL; + char attrbuf[UTIL_PATH_SIZE], *attr; + bool format_dollar = false; + ssize_t subst_len; while (from[0] != '\0') { if (from[0] == '$') { /* substitute named variable */ - unsigned int i; + unsigned i; if (from[1] == '$') { from++; @@ -330,14 +347,15 @@ size_t udev_event_apply_format(struct udev_event *event, for (i = 0; i < ELEMENTSOF(map); i++) { if (startswith(&from[1], map[i].name)) { - type = map[i].type; + entry = &map[i]; from += strlen(map[i].name)+1; + format_dollar = true; goto subst; } } } else if (from[0] == '%') { /* substitute format char */ - unsigned int i; + unsigned i; if (from[1] == '%') { from++; @@ -346,7 +364,7 @@ size_t udev_event_apply_format(struct udev_event *event, for (i = 0; i < ELEMENTSOF(map); i++) { if (from[1] == map[i].fmt) { - type = map[i].type; + entry = &map[i]; from += 2; goto subst; } @@ -366,7 +384,7 @@ copy: subst: /* extract possible $format{attr} */ if (from[0] == '{') { - unsigned int i; + unsigned i; from++; for (i = 0; from[i] != '}'; i++) @@ -381,14 +399,21 @@ subst: attrbuf[i] = '\0'; from += i+1; attr = attrbuf; - } else { + } else attr = NULL; - } - subst_len = subst_format_var(event, dev, type, attr, s, l); + subst_len = subst_format_var(event, entry, attr, s, l); + if (subst_len < 0) { + if (format_dollar) + log_device_warning_errno(event->dev, subst_len, "Failed to substitute variable '$%s', ignoring: %m", entry->name); + else + log_device_warning_errno(event->dev, subst_len, "Failed to apply format '%%%c', ignoring: %m", entry->fmt); + + continue; + } /* SUBST_RESULT handles spaces itself */ - if (replace_whitespace && type != SUBST_RESULT) + if (replace_whitespace && entry->type != SUBST_RESULT) /* util_replace_whitespace can replace in-place, * and does nothing if subst_len == 0 */ @@ -404,210 +429,75 @@ out: return l; } -static int spawn_exec(struct udev_event *event, - const char *cmd, char *const argv[], char **envp, - int fd_stdout, int fd_stderr) { - _cleanup_close_ int fd = -1; - int r; - - /* discard child output or connect to pipe */ - fd = open("/dev/null", O_RDWR); - if (fd >= 0) { - r = dup2(fd, STDIN_FILENO); - if (r < 0) - log_warning_errno(errno, "redirecting stdin failed: %m"); - - if (fd_stdout < 0) { - r = dup2(fd, STDOUT_FILENO); - if (r < 0) - log_warning_errno(errno, "redirecting stdout failed: %m"); - } - - if (fd_stderr < 0) { - r = dup2(fd, STDERR_FILENO); - if (r < 0) - log_warning_errno(errno, "redirecting stderr failed: %m"); - } - } else - log_warning_errno(errno, "open /dev/null failed: %m"); - - /* connect pipes to std{out,err} */ - if (fd_stdout >= 0) { - r = dup2(fd_stdout, STDOUT_FILENO); - if (r < 0) - log_warning_errno(errno, "redirecting stdout failed: %m"); - - fd_stdout = safe_close(fd_stdout); - } - - if (fd_stderr >= 0) { - r = dup2(fd_stderr, STDERR_FILENO); - if (r < 0) - log_warning_errno(errno, "redirecting stdout failed: %m"); - - fd_stderr = safe_close(fd_stderr); - } - - /* terminate child in case parent goes away */ - prctl(PR_SET_PDEATHSIG, SIGTERM); - - /* restore sigmask before exec */ - (void) reset_signal_mask(); - - execve(argv[0], argv, envp); - - /* exec failed */ - return log_error_errno(errno, "failed to execute '%s' '%s': %m", argv[0], cmd); -} - -static void spawn_read(struct udev_event *event, - usec_t timeout_usec, - const char *cmd, - int fd_stdout, int fd_stderr, - char *result, size_t ressize) { - _cleanup_close_ int fd_ep = -1; - struct epoll_event ep_outpipe = { - .events = EPOLLIN, - .data.ptr = &fd_stdout, - }; - struct epoll_event ep_errpipe = { - .events = EPOLLIN, - .data.ptr = &fd_stderr, - }; - size_t respos = 0; - int r; +static int on_spawn_io(sd_event_source *s, int fd, uint32_t revents, void *userdata) { + Spawn *spawn = userdata; + char buf[4096], *p; + size_t size; + ssize_t l; - /* read from child if requested */ - if (fd_stdout < 0 && fd_stderr < 0) - return; + assert(spawn); + assert(fd == spawn->fd_stdout || fd == spawn->fd_stderr); + assert(!spawn->result || spawn->result_len < spawn->result_size); - fd_ep = epoll_create1(EPOLL_CLOEXEC); - if (fd_ep < 0) { - log_error_errno(errno, "error creating epoll fd: %m"); - return; + if (fd == spawn->fd_stdout && spawn->result) { + p = spawn->result + spawn->result_len; + size = spawn->result_size - spawn->result_len; + } else { + p = buf; + size = sizeof(buf); } - if (fd_stdout >= 0) { - r = epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stdout, &ep_outpipe); - if (r < 0) { - log_error_errno(errno, "fail to add stdout fd to epoll: %m"); - return; - } - } + l = read(fd, p, size - 1); + if (l < 0) { + if (errno != EAGAIN) + log_error_errno(errno, "Failed to read stdout of '%s': %m", spawn->cmd); - if (fd_stderr >= 0) { - r = epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stderr, &ep_errpipe); - if (r < 0) { - log_error_errno(errno, "fail to add stderr fd to epoll: %m"); - return; - } + return 0; } - /* read child output */ - while (fd_stdout >= 0 || fd_stderr >= 0) { - int timeout; - int fdcount; - struct epoll_event ev[4]; - int i; - - if (timeout_usec > 0) { - usec_t age_usec; - - age_usec = now(CLOCK_MONOTONIC) - event->birth_usec; - if (age_usec >= timeout_usec) { - log_error("timeout '%s'", cmd); - return; - } - timeout = ((timeout_usec - age_usec) / USEC_PER_MSEC) + MSEC_PER_SEC; - } else { - timeout = -1; - } - - fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), timeout); - if (fdcount < 0) { - if (errno == EINTR) - continue; - log_error_errno(errno, "failed to poll: %m"); - return; - } else if (fdcount == 0) { - log_error("timeout '%s'", cmd); - return; - } - - for (i = 0; i < fdcount; i++) { - int *fd = (int *)ev[i].data.ptr; + p[l] = '\0'; + if (fd == spawn->fd_stdout && spawn->result) + spawn->result_len += l; - if (*fd < 0) - continue; + /* Log output only if we watch stderr. */ + if (l > 0 && spawn->fd_stderr >= 0) { + _cleanup_strv_free_ char **v = NULL; + char **q; - if (ev[i].events & EPOLLIN) { - ssize_t count; - char buf[4096]; + v = strv_split_newlines(p); + if (!v) + return 0; - count = read(*fd, buf, sizeof(buf)-1); - if (count <= 0) - continue; - buf[count] = '\0'; - - /* store stdout result */ - if (result != NULL && *fd == fd_stdout) { - if (respos + count < ressize) { - memcpy(&result[respos], buf, count); - respos += count; - } else { - log_error("'%s' ressize %zu too short", cmd, ressize); - } - } - - /* log debug output only if we watch stderr */ - if (fd_stderr >= 0) { - char *pos; - char *line; - - pos = buf; - while ((line = strsep(&pos, "\n"))) { - if (pos != NULL || line[0] != '\0') - log_debug("'%s'(%s) '%s'", cmd, *fd == fd_stdout ? "out" : "err" , line); - } - } - } else if (ev[i].events & EPOLLHUP) { - r = epoll_ctl(fd_ep, EPOLL_CTL_DEL, *fd, NULL); - if (r < 0) { - log_error_errno(errno, "failed to remove fd from epoll: %m"); - return; - } - *fd = -1; - } - } + STRV_FOREACH(q, v) + log_debug("'%s'(%s) '%s'", spawn->cmd, + fd == spawn->fd_stdout ? "out" : "err", *q); } - /* return the child's stdout string */ - if (result != NULL) - result[respos] = '\0'; + return 0; } static int on_spawn_timeout(sd_event_source *s, uint64_t usec, void *userdata) { Spawn *spawn = userdata; - char timeout[FORMAT_TIMESTAMP_RELATIVE_MAX]; + char timeout[FORMAT_TIMESPAN_MAX]; assert(spawn); kill_and_sigcont(spawn->pid, SIGKILL); - log_error("spawned process '%s' ["PID_FMT"] timed out after %s, killing", spawn->cmd, spawn->pid, - format_timestamp_relative(timeout, sizeof(timeout), spawn->timeout)); + log_error("Spawned process '%s' ["PID_FMT"] timed out after %s, killing", spawn->cmd, spawn->pid, + format_timespan(timeout, sizeof(timeout), spawn->timeout_usec, USEC_PER_SEC)); return 1; } static int on_spawn_timeout_warning(sd_event_source *s, uint64_t usec, void *userdata) { Spawn *spawn = userdata; - char timeout[FORMAT_TIMESTAMP_RELATIVE_MAX]; + char timeout[FORMAT_TIMESPAN_MAX]; assert(spawn); - log_warning("spawned process '%s' ["PID_FMT"] is taking longer than %s to complete", spawn->cmd, spawn->pid, - format_timestamp_relative(timeout, sizeof(timeout), spawn->timeout)); + log_warning("Spawned process '%s' ["PID_FMT"] is taking longer than %s to complete", spawn->cmd, spawn->pid, + format_timespan(timeout, sizeof(timeout), spawn->timeout_warn_usec, USEC_PER_SEC)); return 1; } @@ -624,11 +514,10 @@ static int on_spawn_sigchld(sd_event_source *s, const siginfo_t *si, void *userd sd_event_exit(sd_event_source_get_event(s), 0); return 1; - } else if (spawn->accept_failure) - log_debug("Process '%s' failed with exit code %i.", spawn->cmd, si->si_status); - else - log_warning("Process '%s' failed with exit code %i.", spawn->cmd, si->si_status); + } + log_full(spawn->accept_failure ? LOG_DEBUG : LOG_WARNING, + "Process '%s' failed with exit code %i.", spawn->cmd, si->si_status); break; case CLD_KILLED: case CLD_DUMPED: @@ -644,49 +533,52 @@ static int on_spawn_sigchld(sd_event_source *s, const siginfo_t *si, void *userd return 1; } -static int spawn_wait(struct udev_event *event, - usec_t timeout_usec, - usec_t timeout_warn_usec, - const char *cmd, pid_t pid, - bool accept_failure) { - Spawn spawn = { - .cmd = cmd, - .pid = pid, - .accept_failure = accept_failure, - }; +static int spawn_wait(Spawn *spawn) { _cleanup_(sd_event_unrefp) sd_event *e = NULL; int r, ret; + assert(spawn); + r = sd_event_new(&e); if (r < 0) return r; - if (timeout_usec > 0) { + if (spawn->timeout_usec > 0) { usec_t usec, age_usec; usec = now(CLOCK_MONOTONIC); - age_usec = usec - event->birth_usec; - if (age_usec < timeout_usec) { - if (timeout_warn_usec > 0 && timeout_warn_usec < timeout_usec && age_usec < timeout_warn_usec) { - spawn.timeout_warn = timeout_warn_usec - age_usec; + age_usec = usec - spawn->event_birth_usec; + if (age_usec < spawn->timeout_usec) { + if (spawn->timeout_warn_usec > 0 && + spawn->timeout_warn_usec < spawn->timeout_usec && + spawn->timeout_warn_usec > age_usec) { + spawn->timeout_warn_usec -= age_usec; r = sd_event_add_time(e, NULL, CLOCK_MONOTONIC, - usec + spawn.timeout_warn, USEC_PER_SEC, - on_spawn_timeout_warning, &spawn); + usec + spawn->timeout_warn_usec, USEC_PER_SEC, + on_spawn_timeout_warning, spawn); if (r < 0) return r; } - spawn.timeout = timeout_usec - age_usec; + spawn->timeout_usec -= age_usec; r = sd_event_add_time(e, NULL, CLOCK_MONOTONIC, - usec + spawn.timeout, USEC_PER_SEC, on_spawn_timeout, &spawn); + usec + spawn->timeout_usec, USEC_PER_SEC, on_spawn_timeout, spawn); if (r < 0) return r; } } - r = sd_event_add_child(e, NULL, pid, WEXITED, on_spawn_sigchld, &spawn); + r = sd_event_add_io(e, NULL, spawn->fd_stdout, EPOLLIN, on_spawn_io, spawn); + if (r < 0) + return r; + + r = sd_event_add_io(e, NULL, spawn->fd_stderr, EPOLLIN, on_spawn_io, spawn); + if (r < 0) + return r; + + r = sd_event_add_child(e, NULL, spawn->pid, WEXITED, on_spawn_sigchld, spawn); if (r < 0) return r; @@ -701,257 +593,309 @@ static int spawn_wait(struct udev_event *event, return ret; } -int udev_build_argv(struct udev *udev, char *cmd, int *argc, char *argv[]) { - int i = 0; - char *pos; - - if (strchr(cmd, ' ') == NULL) { - argv[i++] = cmd; - goto out; - } - - pos = cmd; - while (pos != NULL && pos[0] != '\0') { - if (IN_SET(pos[0], '\'', '"')) { - /* do not separate quotes or double quotes */ - char delim[2] = { pos[0], '\0' }; - - pos++; - argv[i] = strsep(&pos, delim); - if (pos != NULL) - while (pos[0] == ' ') - pos++; - } else { - argv[i] = strsep(&pos, " "); - if (pos != NULL) - while (pos[0] == ' ') - pos++; - } - i++; - } -out: - argv[i] = NULL; - if (argc) - *argc = i; - return 0; -} - -int udev_event_spawn(struct udev_event *event, +int udev_event_spawn(UdevEvent *event, usec_t timeout_usec, - usec_t timeout_warn_usec, bool accept_failure, const char *cmd, char *result, size_t ressize) { - int outpipe[2] = {-1, -1}; - int errpipe[2] = {-1, -1}; + _cleanup_close_pair_ int outpipe[2] = {-1, -1}, errpipe[2] = {-1, -1}; + _cleanup_strv_free_ char **argv = NULL; + char **envp = NULL; + Spawn spawn; pid_t pid; - int err = 0; + int r; + + assert(event); + assert(event->dev); + assert(result || ressize == 0); /* pipes from child to parent */ - if (result != NULL || log_get_max_level() >= LOG_INFO) { - if (pipe2(outpipe, O_NONBLOCK) != 0) { - err = log_error_errno(errno, "pipe failed: %m"); - goto out; - } - } - if (log_get_max_level() >= LOG_INFO) { - if (pipe2(errpipe, O_NONBLOCK) != 0) { - err = log_error_errno(errno, "pipe failed: %m"); - goto out; - } + if (result || log_get_max_level() >= LOG_INFO) + if (pipe2(outpipe, O_NONBLOCK|O_CLOEXEC) != 0) + return log_error_errno(errno, "Failed to create pipe for command '%s': %m", cmd); + + if (log_get_max_level() >= LOG_INFO) + if (pipe2(errpipe, O_NONBLOCK|O_CLOEXEC) != 0) + return log_error_errno(errno, "Failed to create pipe for command '%s': %m", cmd); + + argv = strv_split_full(cmd, NULL, SPLIT_QUOTES|SPLIT_RELAX); + if (!argv) + return log_oom(); + + if (isempty(argv[0])) + return log_error_errno(SYNTHETIC_ERRNO(EINVAL), + "Invalid command '%s'", cmd); + + /* allow programs in /usr/lib/udev/ to be called without the path */ + if (!path_is_absolute(argv[0])) { + char *program; + + program = path_join(UDEVLIBEXECDIR, argv[0]); + if (!program) + return log_oom(); + + free_and_replace(argv[0], program); } - err = safe_fork("(spawn)", FORK_RESET_SIGNALS|FORK_LOG, &pid); - if (err < 0) - goto out; - if (err == 0) { - char arg[UTIL_PATH_SIZE]; - char *argv[128]; - char program[UTIL_PATH_SIZE]; - - /* child closes parent's ends of pipes */ - outpipe[READ_END] = safe_close(outpipe[READ_END]); - errpipe[READ_END] = safe_close(errpipe[READ_END]); - - strscpy(arg, sizeof(arg), cmd); - udev_build_argv(event->udev, arg, NULL, argv); - - /* allow programs in /usr/lib/udev/ to be called without the path */ - if (argv[0][0] != '/') { - strscpyl(program, sizeof(program), UDEVLIBEXECDIR "/", argv[0], NULL); - argv[0] = program; - } + r = device_get_properties_strv(event->dev, &envp); + if (r < 0) + return log_device_error_errno(event->dev, r, "Failed to get device properties"); + + log_debug("Starting '%s'", cmd); - log_debug("starting '%s'", cmd); + r = safe_fork("(spawn)", FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_LOG, &pid); + if (r < 0) + return log_error_errno(r, "Failed to fork() to execute command '%s': %m", cmd); + if (r == 0) { + if (rearrange_stdio(-1, outpipe[WRITE_END], errpipe[WRITE_END]) < 0) + _exit(EXIT_FAILURE); - spawn_exec(event, cmd, argv, udev_device_get_properties_envp(event->dev), - outpipe[WRITE_END], errpipe[WRITE_END]); + (void) close_all_fds(NULL, 0); + (void) rlimit_nofile_safe(); - _exit(2); + execve(argv[0], argv, envp); + _exit(EXIT_FAILURE); } /* parent closed child's ends of pipes */ outpipe[WRITE_END] = safe_close(outpipe[WRITE_END]); errpipe[WRITE_END] = safe_close(errpipe[WRITE_END]); - spawn_read(event, - timeout_usec, - cmd, - outpipe[READ_END], errpipe[READ_END], - result, ressize); + spawn = (Spawn) { + .cmd = cmd, + .pid = pid, + .accept_failure = accept_failure, + .timeout_warn_usec = udev_warn_timeout(timeout_usec), + .timeout_usec = timeout_usec, + .event_birth_usec = event->birth_usec, + .fd_stdout = outpipe[READ_END], + .fd_stderr = errpipe[READ_END], + .result = result, + .result_size = ressize, + }; + r = spawn_wait(&spawn); + if (r < 0) + return log_error_errno(r, "Failed to wait spawned command '%s': %m", cmd); - err = spawn_wait(event, timeout_usec, timeout_warn_usec, cmd, pid, accept_failure); + if (result) + result[spawn.result_len] = '\0'; -out: - if (outpipe[READ_END] >= 0) - close(outpipe[READ_END]); - if (outpipe[WRITE_END] >= 0) - close(outpipe[WRITE_END]); - if (errpipe[READ_END] >= 0) - close(errpipe[READ_END]); - if (errpipe[WRITE_END] >= 0) - close(errpipe[WRITE_END]); - return err; + return r; } -static int rename_netif(struct udev_event *event) { - struct udev_device *dev = event->dev; +static int rename_netif(UdevEvent *event) { + sd_device *dev = event->dev; + const char *action, *oldname; char name[IFNAMSIZ]; - const char *oldname; - int r; + int ifindex, r; + + if (!event->name) + return 0; /* No new name is requested. */ - oldname = udev_device_get_sysname(dev); + r = sd_device_get_sysname(dev, &oldname); + if (r < 0) + return log_device_error_errno(dev, r, "Failed to get sysname: %m"); + + if (streq(event->name, oldname)) + return 0; /* The interface name is already requested name. */ + + r = sd_device_get_property_value(dev, "ACTION", &action); + if (r < 0) + return log_device_error_errno(dev, r, "Failed to get property 'ACTION': %m"); + + if (!streq(action, "add")) + return 0; /* Rename the interface only when it is added. */ + + r = sd_device_get_ifindex(dev, &ifindex); + if (r == -ENOENT) + return 0; /* Device is not a network interface. */ + if (r < 0) + return log_device_error_errno(dev, r, "Failed to get ifindex: %m"); strscpy(name, IFNAMSIZ, event->name); + r = rtnl_set_link_name(&event->rtnl, ifindex, name); + if (r < 0) + return log_device_error_errno(dev, r, "Failed to rename network interface %i from '%s' to '%s': %m", ifindex, oldname, name); - r = rtnl_set_link_name(&event->rtnl, udev_device_get_ifindex(dev), name); + r = device_rename(dev, event->name); if (r < 0) - return log_error_errno(r, "Error changing net interface name '%s' to '%s': %m", oldname, name); + return log_warning_errno(r, "Network interface %i is renamed from '%s' to '%s', but could not update sd_device object: %m", ifindex, oldname, name); - log_debug("renamed network interface '%s' to '%s'", oldname, name); + log_device_debug(dev, "Network interface %i is renamed from '%s' to '%s'", ifindex, oldname, name); - return 0; + return 1; } -void udev_event_execute_rules(struct udev_event *event, - usec_t timeout_usec, usec_t timeout_warn_usec, - struct udev_list *properties_list, - struct udev_rules *rules) { - struct udev_device *dev = event->dev; +static int update_devnode(UdevEvent *event) { + sd_device *dev = event->dev; + const char *action; + bool apply; + int r; - if (udev_device_get_subsystem(dev) == NULL) - return; + r = sd_device_get_devnum(dev, NULL); + if (r == -ENOENT) + return 0; + if (r < 0) + return log_device_error_errno(dev, r, "Failed to get devnum: %m"); - if (streq(udev_device_get_action(dev), "remove")) { - udev_device_read_db(dev); - udev_device_tag_index(dev, NULL, false); - udev_device_delete_db(dev); + /* remove/update possible left-over symlinks from old database entry */ + if (event->dev_db_clone) + (void) udev_node_update_old_links(dev, event->dev_db_clone); - if (major(udev_device_get_devnum(dev)) != 0) - udev_watch_end(event->udev, dev); + if (!event->owner_set) { + r = device_get_devnode_uid(dev, &event->uid); + if (r < 0 && r != -ENOENT) + return log_device_error_errno(dev, r, "Failed to get devnode UID: %m"); + } - udev_rules_apply_to_event(rules, event, - timeout_usec, timeout_warn_usec, - properties_list); + if (!event->group_set) { + r = device_get_devnode_gid(dev, &event->gid); + if (r < 0 && r != -ENOENT) + return log_device_error_errno(dev, r, "Failed to get devnode GID: %m"); + } - if (major(udev_device_get_devnum(dev)) != 0) - udev_node_remove(dev); - } else { - event->dev_db = udev_device_clone_with_db(dev); - if (event->dev_db != NULL) { - /* disable watch during event processing */ - if (major(udev_device_get_devnum(dev)) != 0) - udev_watch_end(event->udev, event->dev_db); - - if (major(udev_device_get_devnum(dev)) == 0 && - streq(udev_device_get_action(dev), "move")) - udev_device_copy_properties(dev, event->dev_db); + if (!event->mode_set) { + r = device_get_devnode_mode(dev, &event->mode); + if (r < 0 && r != -ENOENT) + return log_device_error_errno(dev, r, "Failed to get devnode mode: %m"); + if (r == -ENOENT) { + if (event->gid > 0) + /* default 0660 if a group is assigned */ + event->mode = 0660; + else + /* default 0600 */ + event->mode = 0600; } + } + + r = sd_device_get_property_value(dev, "ACTION", &action); + if (r < 0) + return log_device_error_errno(dev, r, "Failed to get property 'ACTION': %m"); - udev_rules_apply_to_event(rules, event, - timeout_usec, timeout_warn_usec, - properties_list); + apply = streq(action, "add") || event->owner_set || event->group_set || event->mode_set; + return udev_node_add(dev, apply, event->mode, event->uid, event->gid, event->seclabel_list); +} - /* rename a new network interface, if needed */ - if (udev_device_get_ifindex(dev) > 0 && streq(udev_device_get_action(dev), "add") && - event->name != NULL && !streq(event->name, udev_device_get_sysname(dev))) { - int r; +static void event_execute_rules_on_remove( + UdevEvent *event, + usec_t timeout_usec, + Hashmap *properties_list, + UdevRules *rules) { - r = rename_netif(event); - if (r < 0) - log_warning_errno(r, "could not rename interface '%d' from '%s' to '%s': %m", udev_device_get_ifindex(dev), - udev_device_get_sysname(dev), event->name); - else { - r = udev_device_rename(dev, event->name); + sd_device *dev = event->dev; + int r; + + r = device_read_db_internal(dev, true); + if (r < 0) + log_device_debug_errno(dev, r, "Failed to read database under /run/udev/data/: %m"); + + r = device_tag_index(dev, NULL, false); + if (r < 0) + log_device_debug_errno(dev, r, "Failed to remove corresponding tag files under /run/udev/tag/, ignoring: %m"); + + r = device_delete_db(dev); + if (r < 0) + log_device_debug_errno(dev, r, "Failed to delete database under /run/udev/data/, ignoring: %m"); + + if (sd_device_get_devnum(dev, NULL) >= 0) + (void) udev_watch_end(dev); + + (void) udev_rules_apply_to_event(rules, event, timeout_usec, properties_list); + + if (sd_device_get_devnum(dev, NULL) >= 0) + (void) udev_node_remove(dev); +} + +int udev_event_execute_rules(UdevEvent *event, + usec_t timeout_usec, + Hashmap *properties_list, + UdevRules *rules) { + sd_device *dev = event->dev; + const char *subsystem, *action; + int r; + + assert(event); + assert(rules); + + r = sd_device_get_subsystem(dev, &subsystem); + if (r < 0) + return log_device_error_errno(dev, r, "Failed to get subsystem: %m"); + + r = sd_device_get_property_value(dev, "ACTION", &action); + if (r < 0) + return log_device_error_errno(dev, r, "Failed to get property 'ACTION': %m"); + + if (streq(action, "remove")) { + event_execute_rules_on_remove(event, timeout_usec, properties_list, rules); + return 0; + } + + r = device_clone_with_db(dev, &event->dev_db_clone); + if (r < 0) + log_device_debug_errno(dev, r, "Failed to clone sd_device object, ignoring: %m"); + + if (event->dev_db_clone) { + r = sd_device_get_devnum(dev, NULL); + if (r < 0) { + if (r != -ENOENT) + log_device_debug_errno(dev, r, "Failed to get devnum, ignoring: %m"); + + if (streq(action, "move")) { + r = device_copy_properties(dev, event->dev_db_clone); if (r < 0) - log_warning_errno(r, "renamed interface '%d' from '%s' to '%s', but could not update udev_device: %m", - udev_device_get_ifindex(dev), udev_device_get_sysname(dev), event->name); - else - log_debug("changed devpath to '%s'", udev_device_get_devpath(dev)); + log_device_debug_errno(dev, r, "Failed to copy properties from cloned device, ignoring: %m"); } - } + } else + /* Disable watch during event processing. */ + (void) udev_watch_end(event->dev_db_clone); + } - if (major(udev_device_get_devnum(dev)) > 0) { - bool apply; - - /* remove/update possible left-over symlinks from old database entry */ - if (event->dev_db != NULL) - udev_node_update_old_links(dev, event->dev_db); - - if (!event->owner_set) - event->uid = udev_device_get_devnode_uid(dev); - - if (!event->group_set) - event->gid = udev_device_get_devnode_gid(dev); - - if (!event->mode_set) { - if (udev_device_get_devnode_mode(dev) > 0) { - /* kernel supplied value */ - event->mode = udev_device_get_devnode_mode(dev); - } else if (event->gid > 0) { - /* default 0660 if a group is assigned */ - event->mode = 0660; - } else { - /* default 0600 */ - event->mode = 0600; - } - } + (void) udev_rules_apply_to_event(rules, event, timeout_usec, properties_list); - apply = streq(udev_device_get_action(dev), "add") || event->owner_set || event->group_set || event->mode_set; - udev_node_add(dev, apply, event->mode, event->uid, event->gid, &event->seclabel_list); - } + (void) rename_netif(event); + (void) update_devnode(event); - /* preserve old, or get new initialization timestamp */ - udev_device_ensure_usec_initialized(event->dev, event->dev_db); + /* preserve old, or get new initialization timestamp */ + r = device_ensure_usec_initialized(dev, event->dev_db_clone); + if (r < 0) + log_device_debug_errno(dev, r, "Failed to set initialization timestamp, ignoring: %m"); - /* (re)write database file */ - udev_device_tag_index(dev, event->dev_db, true); - udev_device_update_db(dev); - udev_device_set_is_initialized(dev); + /* (re)write database file */ + r = device_tag_index(dev, event->dev_db_clone, true); + if (r < 0) + log_device_debug_errno(dev, r, "Failed to update tags under /run/udev/tag/, ignoring: %m"); - event->dev_db = udev_device_unref(event->dev_db); - } + r = device_update_db(dev); + if (r < 0) + log_device_debug_errno(dev, r, "Failed to update database under /run/udev/data/, ignoring: %m"); + + device_set_is_initialized(dev); + + event->dev_db_clone = sd_device_unref(event->dev_db_clone); + + return 0; } -void udev_event_execute_run(struct udev_event *event, usec_t timeout_usec, usec_t timeout_warn_usec) { - struct udev_list_entry *list_entry; +void udev_event_execute_run(UdevEvent *event, usec_t timeout_usec) { + const char *cmd; + void *val; + Iterator i; - udev_list_entry_foreach(list_entry, udev_list_get_entry(&event->run_list)) { + HASHMAP_FOREACH_KEY(val, cmd, event->run_list, i) { + enum udev_builtin_cmd builtin_cmd = PTR_TO_INT(val); char command[UTIL_PATH_SIZE]; - const char *cmd = udev_list_entry_get_name(list_entry); - enum udev_builtin_cmd builtin_cmd = udev_list_entry_get_num(list_entry); udev_event_apply_format(event, cmd, command, sizeof(command), false); - if (builtin_cmd < UDEV_BUILTIN_MAX) + if (builtin_cmd >= 0 && builtin_cmd < _UDEV_BUILTIN_MAX) udev_builtin_run(event->dev, builtin_cmd, command, false); else { - if (event->exec_delay > 0) { + if (event->exec_delay_usec > 0) { log_debug("delay execution of '%s'", command); - sleep(event->exec_delay); + (void) usleep(event->exec_delay_usec); } - udev_event_spawn(event, timeout_usec, timeout_warn_usec, false, command, NULL, 0); + udev_event_spawn(event, timeout_usec, false, command, NULL, 0); } } } |