#include "udev.h"
#include "rtnl-util.h"
-struct udev_event *udev_event_new(struct udev_device *dev)
-{
+struct udev_event *udev_event_new(struct udev_device *dev) {
struct udev *udev = udev_device_get_udev(dev);
struct udev_event *event;
- event = calloc(1, sizeof(struct udev_event));
+ event = new0(struct udev_event, 1);
if (event == NULL)
return NULL;
event->dev = dev;
udev_list_init(udev, &event->seclabel_list, false);
event->fd_signal = -1;
event->birth_usec = now(CLOCK_MONOTONIC);
- event->timeout_usec = 30 * 1000 * 1000;
return event;
}
-void udev_event_unref(struct udev_event *event)
-{
+void udev_event_unref(struct udev_event *event) {
if (event == NULL)
return;
+ sd_rtnl_unref(event->rtnl);
udev_list_cleanup(&event->run_list);
udev_list_cleanup(&event->seclabel_list);
free(event->program_result);
free(event);
}
-size_t udev_event_apply_format(struct udev_event *event, const char *src, char *dest, size_t size)
-{
+size_t udev_event_apply_format(struct udev_event *event, const char *src, char *dest, size_t size) {
struct udev_device *dev = event->dev;
enum subst_type {
SUBST_UNKNOWN,
cpos++;
while (isspace(cpos[0]))
cpos++;
+ if (cpos[0] == '\0')
+ break;
}
if (i > 0) {
log_error("requested part of result string not found");
static int spawn_exec(struct udev_event *event,
const char *cmd, char *const argv[], char **envp, const sigset_t *sigmask,
- int fd_stdout, int fd_stderr)
-{
- int err;
- int fd;
+ int fd_stdout, int fd_stderr) {
+ _cleanup_close_ int fd = -1;
/* discard child output or connect to pipe */
fd = open("/dev/null", O_RDWR);
dup2(fd, STDOUT_FILENO);
if (fd_stderr < 0)
dup2(fd, STDERR_FILENO);
- close(fd);
- } else {
+ } else
log_error("open /dev/null failed: %m");
- }
/* connect pipes to std{out,err} */
if (fd_stdout >= 0) {
dup2(fd_stdout, STDOUT_FILENO);
- close(fd_stdout);
+ safe_close(fd_stdout);
}
if (fd_stderr >= 0) {
dup2(fd_stderr, STDERR_FILENO);
- close(fd_stderr);
+ safe_close(fd_stderr);
}
/* terminate child in case parent goes away */
execve(argv[0], argv, envp);
/* exec failed */
- err = -errno;
log_error("failed to execute '%s' '%s': %m", argv[0], cmd);
- return err;
+
+ return -errno;
}
static void spawn_read(struct udev_event *event,
- const char *cmd,
- int fd_stdout, int fd_stderr,
- char *result, size_t ressize)
-{
+ 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 fd_ep = -1;
- struct epoll_event ep_outpipe, ep_errpipe;
+ int r;
/* read from child if requested */
if (fd_stdout < 0 && fd_stderr < 0)
fd_ep = epoll_create1(EPOLL_CLOEXEC);
if (fd_ep < 0) {
log_error("error creating epoll fd: %m");
- goto out;
+ return;
}
if (fd_stdout >= 0) {
- memzero(&ep_outpipe, sizeof(struct epoll_event));
- ep_outpipe.events = EPOLLIN;
- ep_outpipe.data.ptr = &fd_stdout;
- if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stdout, &ep_outpipe) < 0) {
- log_error("fail to add fd to epoll: %m");
- goto out;
+ r = epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stdout, &ep_outpipe);
+ if (r < 0) {
+ log_error("fail to add stdout fd to epoll: %m");
+ return;
}
}
if (fd_stderr >= 0) {
- memzero(&ep_errpipe, sizeof(struct epoll_event));
- ep_errpipe.events = EPOLLIN;
- ep_errpipe.data.ptr = &fd_stderr;
- if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stderr, &ep_errpipe) < 0) {
- log_error("fail to add fd to epoll: %m");
- goto out;
+ r = epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_stderr, &ep_errpipe);
+ if (r < 0) {
+ log_error("fail to add stderr fd to epoll: %m");
+ return;
}
}
struct epoll_event ev[4];
int i;
- if (event->timeout_usec > 0) {
+ if (timeout_usec > 0) {
usec_t age_usec;
age_usec = now(CLOCK_MONOTONIC) - event->birth_usec;
- if (age_usec >= event->timeout_usec) {
+ if (age_usec >= timeout_usec) {
log_error("timeout '%s'", cmd);
- goto out;
+ return;
}
- timeout = ((event->timeout_usec - age_usec) / 1000) + 1000;
+ timeout = ((timeout_usec - age_usec) / USEC_PER_MSEC) + MSEC_PER_SEC;
} else {
timeout = -1;
}
if (errno == EINTR)
continue;
log_error("failed to poll: %m");
- goto out;
- }
- if (fdcount == 0) {
+ return;
+ } else if (fdcount == 0) {
log_error("timeout '%s'", cmd);
- goto out;
+ return;
}
for (i = 0; i < fdcount; i++) {
int *fd = (int *)ev[i].data.ptr;
+ if (*fd < 0)
+ continue;
+
if (ev[i].events & EPOLLIN) {
ssize_t count;
char buf[4096];
}
}
} else if (ev[i].events & EPOLLHUP) {
- if (epoll_ctl(fd_ep, EPOLL_CTL_DEL, *fd, NULL) < 0) {
+ r = epoll_ctl(fd_ep, EPOLL_CTL_DEL, *fd, NULL);
+ if (r < 0) {
log_error("failed to remove fd from epoll: %m");
- goto out;
+ return;
}
*fd = -1;
}
/* return the child's stdout string */
if (result != NULL)
result[respos] = '\0';
-out:
- if (fd_ep >= 0)
- close(fd_ep);
}
-static int spawn_wait(struct udev_event *event, const char *cmd, pid_t pid)
-{
+static int spawn_wait(struct udev_event *event,
+ usec_t timeout_usec,
+ usec_t timeout_warn_usec,
+ const char *cmd, pid_t pid) {
struct pollfd pfd[1];
int err = 0;
while (pid > 0) {
int timeout;
+ int timeout_warn = 0;
int fdcount;
- if (event->timeout_usec > 0) {
+ if (timeout_usec > 0) {
usec_t age_usec;
age_usec = now(CLOCK_MONOTONIC) - event->birth_usec;
- if (age_usec >= event->timeout_usec)
+ if (age_usec >= timeout_usec)
timeout = 1000;
- else
- timeout = ((event->timeout_usec - age_usec) / 1000) + 1000;
+ else {
+ if (timeout_warn_usec > 0)
+ timeout_warn = ((timeout_warn_usec - age_usec) / USEC_PER_MSEC) + MSEC_PER_SEC;
+
+ timeout = ((timeout_usec - timeout_warn_usec - age_usec) / USEC_PER_MSEC) + MSEC_PER_SEC;
+ }
} else {
timeout = -1;
}
- fdcount = poll(pfd, 1, timeout);
+ fdcount = poll(pfd, 1, timeout_warn);
if (fdcount < 0) {
if (errno == EINTR)
continue;
goto out;
}
if (fdcount == 0) {
- log_error("timeout: killing '%s' [%u]", cmd, pid);
- kill(pid, SIGKILL);
+ log_warning("slow: '%s' [%u]", cmd, pid);
+
+ fdcount = poll(pfd, 1, timeout);
+ if (fdcount < 0) {
+ if (errno == EINTR)
+ continue;
+ err = -errno;
+ log_error("failed to poll: %m");
+ goto out;
+ }
+ if (fdcount == 0) {
+ log_error("timeout: killing '%s' [%u]", cmd, pid);
+ kill(pid, SIGKILL);
+ }
}
if (pfd[0].revents & POLLIN) {
return err;
}
-int udev_build_argv(struct udev *udev, char *cmd, int *argc, char *argv[])
-{
+int udev_build_argv(struct udev *udev, char *cmd, int *argc, char *argv[]) {
int i = 0;
char *pos;
}
int udev_event_spawn(struct udev_event *event,
+ usec_t timeout_usec,
+ usec_t timeout_warn_usec,
const char *cmd, char **envp, const sigset_t *sigmask,
- char *result, size_t ressize)
-{
- struct udev *udev = event->udev;
+ char *result, size_t ressize) {
int outpipe[2] = {-1, -1};
int errpipe[2] = {-1, -1};
pid_t pid;
udev_build_argv(event->udev, arg, NULL, argv);
/* pipes from child to parent */
- if (result != NULL || udev_get_log_priority(udev) >= LOG_INFO) {
+ if (result != NULL || log_get_max_level() >= LOG_INFO) {
if (pipe2(outpipe, O_NONBLOCK) != 0) {
err = -errno;
log_error("pipe failed: %m");
goto out;
}
}
- if (udev_get_log_priority(udev) >= LOG_INFO) {
+ if (log_get_max_level() >= LOG_INFO) {
if (pipe2(errpipe, O_NONBLOCK) != 0) {
err = -errno;
log_error("pipe failed: %m");
errpipe[WRITE_END] = -1;
}
- spawn_read(event, cmd,
- outpipe[READ_END], errpipe[READ_END],
- result, ressize);
+ spawn_read(event,
+ timeout_usec,
+ cmd,
+ outpipe[READ_END], errpipe[READ_END],
+ result, ressize);
- err = spawn_wait(event, cmd, pid);
+ err = spawn_wait(event, timeout_usec, timeout_warn_usec, cmd, pid);
}
out:
return err;
}
-static int rename_netif(struct udev_event *event)
-{
+static int rename_netif(struct udev_event *event) {
struct udev_device *dev = event->dev;
- _cleanup_sd_rtnl_unref_ sd_rtnl *rtnl = NULL;
char name[IFNAMSIZ];
const char *oldname;
int r;
oldname = udev_device_get_sysname(dev);
- log_debug("changing net interface name from '%s' to '%s'",
- oldname, event->name);
-
strscpy(name, IFNAMSIZ, event->name);
- r = sd_rtnl_open(0, &rtnl);
- if (r < 0)
+ r = rtnl_set_link_name(&event->rtnl, udev_device_get_ifindex(dev), name);
+ if (r < 0) {
+ log_error("error changing net interface name '%s' to '%s': %s",
+ oldname, name, strerror(-r));
return r;
+ }
- r = rtnl_set_link_name(rtnl, udev_device_get_ifindex(dev), name);
- if (r < 0)
- log_error("error changing net interface name %s to %s: %s",
- oldname, name, strerror(-r));
- else
- print_kmsg("renamed network interface %s to %s", oldname, name);
+ log_debug("renamed network interface '%s' to '%s'", oldname, name);
- return r;
+ return 0;
}
-int udev_event_execute_rules(struct udev_event *event, struct udev_rules *rules, const sigset_t *sigmask)
-{
+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,
+ const sigset_t *sigmask) {
struct udev_device *dev = event->dev;
- int err = 0;
if (udev_device_get_subsystem(dev) == NULL)
- return -1;
+ return;
if (streq(udev_device_get_action(dev), "remove")) {
udev_device_read_db(dev, NULL);
if (major(udev_device_get_devnum(dev)) != 0)
udev_watch_end(event->udev, dev);
- udev_rules_apply_to_event(rules, event, sigmask);
+ udev_rules_apply_to_event(rules, event,
+ timeout_usec, timeout_warn_usec,
+ properties_list,
+ sigmask);
if (major(udev_device_get_devnum(dev)) != 0)
udev_node_remove(dev);
if (event->dev_db != NULL) {
udev_device_set_syspath(event->dev_db, udev_device_get_syspath(dev));
udev_device_set_subsystem(event->dev_db, udev_device_get_subsystem(dev));
+ udev_device_set_devnum(event->dev_db, udev_device_get_devnum(dev));
udev_device_read_db(event->dev_db, NULL);
udev_device_set_info_loaded(event->dev_db);
udev_watch_end(event->udev, event->dev_db);
}
- udev_rules_apply_to_event(rules, event, sigmask);
+ if (major(udev_device_get_devnum(dev)) == 0 &&
+ streq(udev_device_get_action(dev), "move")) {
+ struct udev_list_entry *entry;
+
+ for ((entry = udev_device_get_properties_list_entry(event->dev_db)); entry; entry = udev_list_entry_get_next(entry)) {
+ const char *key, *value;
+ struct udev_list_entry *property;
+
+ key = udev_list_entry_get_name(entry);
+ value = udev_list_entry_get_value(entry);
+
+ property = udev_device_add_property(event->dev, key, value);
+ udev_list_entry_set_num(property, true);
+ }
+ }
+
+ udev_rules_apply_to_event(rules, event,
+ timeout_usec, timeout_warn_usec,
+ properties_list,
+ sigmask);
/* 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))) {
char syspath[UTIL_PATH_SIZE];
char *pos;
+ int r;
- err = rename_netif(event);
- if (err == 0) {
- log_debug("renamed netif to '%s'", event->name);
-
+ r = rename_netif(event);
+ if (r >= 0) {
/* remember old name */
udev_device_add_property(dev, "INTERFACE_OLD", udev_device_get_sysname(dev));
udev_device_unref(event->dev_db);
event->dev_db = NULL;
}
- return err;
}
-void udev_event_execute_run(struct udev_event *event, const sigset_t *sigmask)
-{
+void udev_event_execute_run(struct udev_event *event, usec_t timeout_usec, usec_t timeout_warn_usec, const sigset_t *sigmask) {
struct udev_list_entry *list_entry;
udev_list_entry_foreach(list_entry, udev_list_get_entry(&event->run_list)) {
udev_event_apply_format(event, cmd, program, sizeof(program));
envp = udev_device_get_properties_envp(event->dev);
- udev_event_spawn(event, program, envp, sigmask, NULL, 0);
+ udev_event_spawn(event, timeout_usec, timeout_warn_usec, program, envp, sigmask, NULL, 0);
}
}
}
~ianmdlvl / elogind.git / blobdiff