diff --git a/src/basic/path-util.c b/src/basic/path-util.c index 338377d918..41e0d4d753 100644 --- a/src/basic/path-util.c +++ b/src/basic/path-util.c @@ -193,6 +193,24 @@ int path_make_relative(const char *from, const char *to, char **ret) { return 0; } +int path_make_relative_parent(const char *from_child, const char *to, char **ret) { + _cleanup_free_ char *from = NULL; + int r; + + assert(from_child); + assert(to); + assert(ret); + + /* Similar to path_make_relative(), but provides the relative path from the parent directory of + * 'from_child'. This may be useful when creating relative symlink. */ + + r = path_extract_directory(from_child, &from); + if (r < 0) + return r; + + return path_make_relative(from, to, ret); +} + char* path_startswith_strv(const char *p, char **set) { STRV_FOREACH(s, set) { char *t; diff --git a/src/basic/path-util.h b/src/basic/path-util.h index 41bbc7bb86..8cd7f512a6 100644 --- a/src/basic/path-util.h +++ b/src/basic/path-util.h @@ -61,6 +61,7 @@ char* path_make_absolute(const char *p, const char *prefix); int safe_getcwd(char **ret); int path_make_absolute_cwd(const char *p, char **ret); int path_make_relative(const char *from, const char *to, char **ret); +int path_make_relative_parent(const char *from_child, const char *to, char **ret); char *path_startswith_full(const char *path, const char *prefix, bool accept_dot_dot) _pure_; static inline char* path_startswith(const char *path, const char *prefix) { return path_startswith_full(path, prefix, true); diff --git a/src/test/test-path-util.c b/src/test/test-path-util.c index e0583cfbab..a26e351233 100644 --- a/src/test/test-path-util.c +++ b/src/test/test-path-util.c @@ -477,6 +477,33 @@ TEST(path_make_relative) { test_path_make_relative_one("//extra.//.//./.slashes//./won't////fo.ol///anybody//", "/././/extra././/.slashes////ar.e/.just/././.fine///", "../../../ar.e/.just/.fine"); } +static void test_path_make_relative_parent_one(const char *from, const char *to, const char *expected) { + _cleanup_free_ char *z = NULL; + int r; + + log_info("/* %s(%s, %s) */", __func__, from, to); + + r = path_make_relative_parent(from, to, &z); + assert_se((r >= 0) == !!expected); + assert_se(streq_ptr(z, expected)); +} + +TEST(path_make_relative_parent) { + test_path_make_relative_parent_one("some/relative/path/hoge", "/some/path", NULL); + test_path_make_relative_parent_one("/some/path/hoge", "some/relative/path", NULL); + test_path_make_relative_parent_one("/some/dotdot/../path/hoge", "/some/path", NULL); + test_path_make_relative_parent_one("/", "/aaa", NULL); + + test_path_make_relative_parent_one("/hoge", "/", "."); + test_path_make_relative_parent_one("/hoge", "/some/path", "some/path"); + test_path_make_relative_parent_one("/some/path/hoge", "/some/path", "."); + test_path_make_relative_parent_one("/some/path/hoge", "/some/path/in/subdir", "in/subdir"); + test_path_make_relative_parent_one("/some/path/hoge", "/", "../.."); + test_path_make_relative_parent_one("/some/path/hoge", "/some/other/path", "../other/path"); + test_path_make_relative_parent_one("/some/path/./dot/hoge", "/some/further/path", "../../further/path"); + test_path_make_relative_parent_one("//extra.//.//./.slashes//./won't////fo.ol///anybody//hoge", "/././/extra././/.slashes////ar.e/.just/././.fine///", "../../../ar.e/.just/.fine"); +} + TEST(path_strv_resolve) { char tmp_dir[] = "/tmp/test-path-util-XXXXXX"; _cleanup_strv_free_ char **search_dirs = NULL; diff --git a/src/udev/udev-node.c b/src/udev/udev-node.c index bb34977d97..4e7dca06de 100644 --- a/src/udev/udev-node.c +++ b/src/udev/udev-node.c @@ -1,11 +1,6 @@ /* SPDX-License-Identifier: GPL-2.0-or-later */ -#include -#include -#include -#include -#include -#include +#include #include "sd-id128.h" @@ -22,73 +17,84 @@ #include "mkdir-label.h" #include "parse-util.h" #include "path-util.h" -#include "random-util.h" #include "selinux-util.h" #include "smack-util.h" #include "stat-util.h" -#include "stdio-util.h" #include "string-util.h" -#include "strxcpyx.h" -#include "time-util.h" #include "udev-node.h" #include "user-util.h" -#define CREATE_LINK_MAX_RETRIES 128 -#define LINK_UPDATE_MAX_RETRIES 128 -#define CREATE_STACK_LINK_MAX_RETRIES 128 -#define UPDATE_TIMESTAMP_MAX_RETRIES 128 -#define MAX_RANDOM_DELAY (250 * USEC_PER_MSEC) -#define MIN_RANDOM_DELAY ( 50 * USEC_PER_MSEC) #define UDEV_NODE_HASH_KEY SD_ID128_MAKE(b9,6a,f1,ce,40,31,44,1a,9e,19,ec,8b,ae,f3,e3,2f) -static int create_symlink(const char *target, const char *slink) { - int r; +int udev_node_cleanup(void) { + _cleanup_closedir_ DIR *dir = NULL; - assert(target); - assert(slink); + /* This must not be called when any workers exist. It would cause a race between mkdir() called + * by stack_directory_lock() and unlinkat() called by this. */ - for (unsigned i = 0; i < CREATE_LINK_MAX_RETRIES; i++) { - r = mkdir_parents_label(slink, 0755); - if (r == -ENOENT) - continue; - if (r < 0) - return r; + dir = opendir("/run/udev/links"); + if (!dir) { + if (errno == ENOENT) + return 0; - mac_selinux_create_file_prepare(slink, S_IFLNK); - r = RET_NERRNO(symlink(target, slink)); - mac_selinux_create_file_clear(); - if (r != -ENOENT) - return r; + return log_debug_errno(errno, "Failed to open directory '/run/udev/links', ignoring: %m"); } - return r; + FOREACH_DIRENT_ALL(de, dir, break) { + _cleanup_free_ char *lockfile = NULL; + + if (de->d_name[0] == '.') + continue; + + if (de->d_type != DT_DIR) + continue; + + /* As commented in the above, this is called when no worker exists, hence the file is not + * locked. On a later uevent, the lock file will be created if necessary. So, we can safely + * remove the file now. */ + lockfile = path_join(de->d_name, ".lock"); + if (!lockfile) + return log_oom_debug(); + + if (unlinkat(dirfd(dir), lockfile, 0) < 0 && errno != ENOENT) { + log_debug_errno(errno, "Failed to remove '/run/udev/links/%s', ignoring: %m", lockfile); + continue; + } + + if (unlinkat(dirfd(dir), de->d_name, AT_REMOVEDIR) < 0 && errno != ENOTEMPTY) + log_debug_errno(errno, "Failed to remove '/run/udev/links/%s', ignoring: %m", de->d_name); + } + + return 0; } -static int node_symlink(sd_device *dev, const char *node, const char *slink) { - _cleanup_free_ char *slink_dirname = NULL, *target = NULL; +static int node_symlink(sd_device *dev, const char *devnode, const char *slink) { + _cleanup_free_ char *target = NULL; const char *id, *slink_tmp; - struct stat stats; + struct stat st; int r; assert(dev); - assert(node); assert(slink); - if (lstat(slink, &stats) >= 0) { - if (!S_ISLNK(stats.st_mode)) + if (!devnode) { + r = sd_device_get_devname(dev, &devnode); + if (r < 0) + return log_device_debug_errno(dev, r, "Failed to get device node: %m"); + } + + if (lstat(slink, &st) >= 0) { + if (!S_ISLNK(st.st_mode)) return log_device_debug_errno(dev, SYNTHETIC_ERRNO(EEXIST), - "Conflicting inode '%s' found, link to '%s' will not be created.", slink, node); + "Conflicting inode '%s' found, symlink to '%s' will not be created.", + slink, devnode); } else if (errno != ENOENT) return log_device_debug_errno(dev, errno, "Failed to lstat() '%s': %m", slink); - r = path_extract_directory(slink, &slink_dirname); - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to get parent directory of '%s': %m", slink); - /* use relative link */ - r = path_make_relative(slink_dirname, node, &target); + r = path_make_relative_parent(slink, devnode, &target); if (r < 0) - return log_device_debug_errno(dev, r, "Failed to get relative path from '%s' to '%s': %m", slink, node); + return log_device_debug_errno(dev, r, "Failed to get relative path from '%s' to '%s': %m", slink, devnode); r = device_get_device_id(dev, &id); if (r < 0) @@ -97,7 +103,13 @@ static int node_symlink(sd_device *dev, const char *node, const char *slink) { slink_tmp = strjoina(slink, ".tmp-", id); (void) unlink(slink_tmp); - r = create_symlink(target, slink_tmp); + r = mkdir_parents_label(slink_tmp, 0755); + if (r < 0) + return log_device_debug_errno(dev, r, "Failed to create parent directory of '%s': %m", slink_tmp); + + mac_selinux_create_file_prepare(slink_tmp, S_IFLNK); + r = RET_NERRNO(symlink(target, slink_tmp)); + mac_selinux_create_file_clear(); if (r < 0) return log_device_debug_errno(dev, r, "Failed to create symlink '%s' to '%s': %m", slink_tmp, target); @@ -110,52 +122,44 @@ static int node_symlink(sd_device *dev, const char *node, const char *slink) { return 0; } -static int link_find_prioritized(sd_device *dev, bool add, const char *stackdir, char **ret) { +static int stack_directory_find_prioritized_devnode(sd_device *dev, const char *dirname, bool add, char **ret) { _cleanup_closedir_ DIR *dir = NULL; - _cleanup_free_ char *target = NULL; + _cleanup_free_ char *devnode = NULL; int r, priority = 0; const char *id; assert(dev); - assert(stackdir); + assert(dirname); assert(ret); /* Find device node of device with highest priority. This returns 1 if a device found, 0 if no - * device found, or a negative errno. */ + * device found, or a negative errno on error. */ if (add) { - const char *devnode; + const char *n; r = device_get_devlink_priority(dev, &priority); if (r < 0) return r; - r = sd_device_get_devname(dev, &devnode); + r = sd_device_get_devname(dev, &n); if (r < 0) return r; - target = strdup(devnode); - if (!target) + devnode = strdup(n); + if (!devnode) return -ENOMEM; } - dir = opendir(stackdir); - if (!dir) { - if (add) /* The stack directory must exist. */ - return -errno; - if (errno != ENOENT) - return -errno; - - *ret = NULL; - return 0; - } + dir = opendir(dirname); + if (!dir) + return -errno; r = device_get_device_id(dev, &id); if (r < 0) return r; FOREACH_DIRENT_ALL(de, dir, break) { - _cleanup_free_ char *path = NULL, *buf = NULL; int tmp_prio; if (de->d_name[0] == '.') @@ -165,35 +169,37 @@ static int link_find_prioritized(sd_device *dev, bool add, const char *stackdir, if (streq(de->d_name, id)) continue; - path = path_join(stackdir, de->d_name); - if (!path) - return -ENOMEM; - - if (readlink_malloc(path, &buf) >= 0) { - char *devnode; + if (de->d_type == DT_LNK) { + _cleanup_free_ char *buf = NULL; + char *colon; /* New format. The devnode and priority can be obtained from symlink. */ - devnode = strchr(buf, ':'); - if (!devnode || devnode == buf) + r = readlinkat_malloc(dirfd(dir), de->d_name, &buf); + if (r < 0) { + log_device_debug_errno(dev, r, "Failed to read symlink %s, ignoring: %m", de->d_name); + continue; + } + + colon = strchr(buf, ':'); + if (!colon || colon == buf) continue; - *(devnode++) = '\0'; - if (!path_startswith(devnode, "/dev")) - continue; + *colon = '\0'; if (safe_atoi(buf, &tmp_prio) < 0) continue; - if (target && tmp_prio <= priority) + if (devnode && tmp_prio <= priority) continue; - r = free_and_strdup(&target, devnode); + r = free_and_strdup(&devnode, colon + 1); if (r < 0) return r; - } else { + + } else if (de->d_type == DT_REG) { _cleanup_(sd_device_unrefp) sd_device *tmp_dev = NULL; - const char *devnode; + const char *val; /* Old format. The devnode and priority must be obtained from uevent and * udev database files. */ @@ -204,24 +210,104 @@ static int link_find_prioritized(sd_device *dev, bool add, const char *stackdir, if (device_get_devlink_priority(tmp_dev, &tmp_prio) < 0) continue; - if (target && tmp_prio <= priority) + if (devnode && tmp_prio <= priority) continue; - if (sd_device_get_devname(tmp_dev, &devnode) < 0) + if (sd_device_get_devname(tmp_dev, &val) < 0) continue; - r = free_and_strdup(&target, devnode); + r = free_and_strdup(&devnode, val); if (r < 0) return r; - } + + } else + continue; priority = tmp_prio; } - *ret = TAKE_PTR(target); + *ret = TAKE_PTR(devnode); return !!*ret; } +static int stack_directory_update(sd_device *dev, int fd, bool add) { + const char *id; + int r; + + assert(dev); + assert(fd >= 0); + + r = device_get_device_id(dev, &id); + if (r < 0) + return r; + + if (add) { + _cleanup_free_ char *data = NULL, *buf = NULL; + const char *devname; + int priority; + + r = sd_device_get_devname(dev, &devname); + if (r < 0) + return r; + + r = device_get_devlink_priority(dev, &priority); + if (r < 0) + return r; + + if (asprintf(&data, "%i:%s", priority, devname) < 0) + return -ENOMEM; + + if (readlinkat_malloc(fd, id, &buf) >= 0 && streq(buf, data)) + return 0; /* Unchanged. */ + + (void) unlinkat(fd, id, 0); + + if (symlinkat(data, fd, id) < 0) + return -errno; + + } else { + if (unlinkat(fd, id, 0) < 0) { + if (errno == ENOENT) + return 0; /* Unchanged. */ + return -errno; + } + } + + return 1; /* Updated. */ +} + +static int stack_directory_open(const char *dirname) { + _cleanup_close_ int fd = -1; + int r; + + assert(dirname); + + r = mkdir_parents(dirname, 0755); + if (r < 0) + return r; + + fd = open_mkdir_at(AT_FDCWD, dirname, O_CLOEXEC | O_DIRECTORY | O_NOFOLLOW | O_RDONLY, 0755); + if (fd < 0) + return fd; + + return TAKE_FD(fd); +} + +static int stack_directory_lock(int dirfd) { + _cleanup_close_ int fd = -1; + + assert(dirfd >= 0); + + fd = openat(dirfd, ".lock", O_CLOEXEC | O_NOFOLLOW | O_RDONLY | O_CREAT, 0600); + if (fd < 0) + return -errno; + + if (flock(fd, LOCK_EX) < 0) + return -errno; + + return TAKE_FD(fd); +} + size_t udev_node_escape_path(const char *src, char *dest, size_t size) { size_t i, j; uint64_t h; @@ -264,229 +350,75 @@ toolong: return size - 1; } -static int update_timestamp(sd_device *dev, const char *path, struct stat *prev) { - assert(path); - assert(prev); - - /* Even if a symlink in the stack directory is created/removed, the mtime of the directory may - * not be changed. Why? Let's consider the following situation. For simplicity, let's assume - * there exist two udev workers (A and B) and all of them calls link_update() for the same - * devlink simultaneously. - * - * 1. A creates/removes a symlink in the stack directory. - * 2. A calls the first stat() in the loop of link_update(). - * 3. A calls link_find_prioritized(). - * 4. B creates/removes another symlink in the stack directory, so the result of the step 3 is outdated. - * 5. B finishes link_update(). - * 6. A creates/removes devlink according to the outdated result in the step 3. - * 7. A calls the second stat() in the loop of link_update(). - * - * If these 7 steps are processed in this order within a short time period that kernel's timer - * does not increase, then even if the contents in the stack directory is changed, the results - * of two stat() called by A shows the same timestamp, and A cannot detect the change. - * - * By calling this function after creating/removing symlinks in the stack directory, the - * timestamp of the stack directory is always increased at least in the above step 5, so A can - * detect the update. */ - - if ((prev->st_mode & S_IFMT) == 0) - return 0; /* Does not exist, or previous stat() failed. */ - - for (unsigned i = 0; i < UPDATE_TIMESTAMP_MAX_RETRIES; i++) { - struct stat st; - - if (stat(path, &st) < 0) - return -errno; - - if (!stat_inode_unmodified(prev, &st)) - return 0; - - log_device_debug(dev, - "%s is modified, but its timestamp is not changed, " - "updating timestamp after 10ms.", - path); - - (void) usleep(10 * USEC_PER_MSEC); - if (utimensat(AT_FDCWD, path, NULL, 0) < 0) - return -errno; - } - - return -ELOOP; -} - -static int update_stack_directory(sd_device *dev, const char *dirname, bool add) { - _cleanup_free_ char *filename = NULL, *data = NULL, *buf = NULL; - const char *devname, *id; - struct stat st = {}; - int priority, r; - - assert(dev); - assert(dirname); - - r = device_get_device_id(dev, &id); - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to get device id: %m"); - - filename = path_join(dirname, id); - if (!filename) - return log_oom_debug(); - - if (!add) { - int unlink_error = 0, stat_error = 0; - - if (stat(dirname, &st) < 0) { - if (errno == ENOENT) - return 0; /* The stack directory is already removed. That's OK. */ - stat_error = -errno; - } - - if (unlink(filename) < 0) - unlink_error = -errno; - - if (rmdir(dirname) >= 0 || errno == ENOENT) - return 0; - - if (unlink_error < 0) { - if (unlink_error == -ENOENT) - return 0; - - /* If we failed to remove the symlink, then there is almost nothing we can do. */ - return log_device_debug_errno(dev, unlink_error, "Failed to remove %s: %m", filename); - } - - if (stat_error < 0) - return log_device_debug_errno(dev, stat_error, "Failed to stat %s: %m", dirname); - - /* The symlink was removed. Check if the timestamp of directory is changed. */ - r = update_timestamp(dev, dirname, &st); - if (r < 0 && r != -ENOENT) - return log_device_debug_errno(dev, r, "Failed to update timestamp of %s: %m", dirname); - - return 0; - } - - r = sd_device_get_devname(dev, &devname); - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to get device node: %m"); - - r = device_get_devlink_priority(dev, &priority); - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to get priority of device node symlink: %m"); - - if (asprintf(&data, "%i:%s", priority, devname) < 0) - return log_oom_debug(); - - if (readlink_malloc(filename, &buf) >= 0 && streq(buf, data)) - return 0; - - if (unlink(filename) < 0 && errno != ENOENT) - log_device_debug_errno(dev, errno, "Failed to remove %s, ignoring: %m", filename); - - for (unsigned j = 0; j < CREATE_STACK_LINK_MAX_RETRIES; j++) { - /* This may fail with -ENOENT when the parent directory is removed during - * creating the file by another udevd worker. */ - r = mkdir_p(dirname, 0755); - if (r == -ENOENT) - continue; - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to create directory %s: %m", dirname); - - if (stat(dirname, &st) < 0) { - if (errno == ENOENT) - continue; - return log_device_debug_errno(dev, errno, "Failed to stat %s: %m", dirname); - } - - if (symlink(data, filename) < 0) { - if (errno == ENOENT) - continue; - return log_device_debug_errno(dev, errno, "Failed to create symbolic link %s: %m", filename); - } - - /* The symlink was created. Check if the timestamp of directory is changed. */ - r = update_timestamp(dev, dirname, &st); - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to update timestamp of %s: %m", dirname); - - return 0; - } - - return log_device_debug_errno(dev, SYNTHETIC_ERRNO(ELOOP), "Failed to create symbolic link %s: %m", filename); -} - -/* manage "stack of names" with possibly specified device priorities */ -static int link_update(sd_device *dev, const char *slink_in, bool add) { - _cleanup_free_ char *slink = NULL, *dirname = NULL; - const char *slink_name; +static int stack_directory_get_name(const char *slink, char **ret) { + _cleanup_free_ char *s = NULL, *dirname = NULL; char name_enc[NAME_MAX+1]; + const char *name; + + assert(slink); + assert(ret); + + s = strdup(slink); + if (!s) + return -ENOMEM; + + path_simplify(s); + + if (!path_is_normalized(s)) + return -EINVAL; + + name = path_startswith(s, "/dev"); + if (empty_or_root(name)) + return -EINVAL; + + udev_node_escape_path(name, name_enc, sizeof(name_enc)); + + dirname = path_join("/run/udev/links", name_enc); + if (!dirname) + return -ENOMEM; + + *ret = TAKE_PTR(dirname); + return 0; +} + +static int link_update(sd_device *dev, const char *slink, bool add) { + _cleanup_free_ char *dirname = NULL, *devnode = NULL; + _cleanup_close_ int dirfd = -1, lockfd = -1; int r; assert(dev); - assert(slink_in); + assert(slink); - slink = strdup(slink_in); - if (!slink) - return log_oom_debug(); - - path_simplify(slink); - - slink_name = path_startswith(slink, "/dev"); - if (!slink_name || - empty_or_root(slink_name) || - !path_is_normalized(slink_name)) - return log_device_debug_errno(dev, SYNTHETIC_ERRNO(EINVAL), - "Invalid symbolic link of device node: %s", slink); - - (void) udev_node_escape_path(slink_name, name_enc, sizeof(name_enc)); - dirname = path_join("/run/udev/links", name_enc); - if (!dirname) - return log_oom_debug(); - - r = update_stack_directory(dev, dirname, add); + r = stack_directory_get_name(slink, &dirname); if (r < 0) - return r; + return log_device_debug_errno(dev, r, "Failed to build stack directory name for '%s': %m", slink); - for (unsigned i = 0; i < LINK_UPDATE_MAX_RETRIES; i++) { - _cleanup_free_ char *target = NULL; - struct stat st1 = {}, st2 = {}; + dirfd = stack_directory_open(dirname); + if (dirfd < 0) + return log_device_debug_errno(dev, dirfd, "Failed to open stack directory '%s': %m", dirname); - if (i > 0) { - usec_t delay = MIN_RANDOM_DELAY + random_u64_range(MAX_RANDOM_DELAY - MIN_RANDOM_DELAY); + lockfd = stack_directory_lock(dirfd); + if (lockfd < 0) + return log_device_debug_errno(dev, lockfd, "Failed to lock stack directory '%s': %m", dirname); - log_device_debug(dev, "Directory %s was updated, retrying to update devlink %s after %s.", - dirname, slink, FORMAT_TIMESPAN(delay, USEC_PER_MSEC)); - (void) usleep(delay); - } + r = stack_directory_update(dev, dirfd, add); + if (r < 0) + return log_device_debug_errno(dev, r, "Failed to update stack directory '%s': %m", dirname); - if (stat(dirname, &st1) < 0 && errno != ENOENT) - return log_device_debug_errno(dev, errno, "Failed to stat %s: %m", dirname); + r = stack_directory_find_prioritized_devnode(dev, dirname, add, &devnode); + if (r < 0) + return log_device_debug_errno(dev, r, "Failed to determine device node with the highest priority for '%s': %m", slink); + if (r > 0) + return node_symlink(dev, devnode, slink); - r = link_find_prioritized(dev, add, dirname, &target); - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to determine device node with the highest priority for '%s': %m", slink); - if (r == 0) { - log_device_debug(dev, "No reference left for '%s', removing", slink); + log_device_debug(dev, "No reference left for '%s', removing", slink); - if (unlink(slink) < 0 && errno != ENOENT) - log_device_debug_errno(dev, errno, "Failed to remove '%s', ignoring: %m", slink); + if (unlink(slink) < 0 && errno != ENOENT) + log_device_debug_errno(dev, errno, "Failed to remove '%s', ignoring: %m", slink); - (void) rmdir_parents(slink, "/dev"); - return 0; - } + (void) rmdir_parents(slink, "/dev"); - r = node_symlink(dev, target, slink); - if (r < 0) - return r; - - if (stat(dirname, &st2) < 0 && errno != ENOENT) - return log_device_debug_errno(dev, errno, "Failed to stat %s: %m", dirname); - - if (((st1.st_mode & S_IFMT) == 0 && (st2.st_mode & S_IFMT) == 0) || - stat_inode_unmodified(&st1, &st2)) - return 0; - } - - return -ELOOP; + return 0; } static int device_get_devpath_by_devnum(sd_device *dev, char **ret) { @@ -510,23 +442,12 @@ static int device_get_devpath_by_devnum(sd_device *dev, char **ret) { int udev_node_update(sd_device *dev, sd_device *dev_old) { _cleanup_free_ char *filename = NULL; - const char *devnode, *devlink; + const char *devlink; int r; assert(dev); assert(dev_old); - r = sd_device_get_devname(dev, &devnode); - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to get devnode: %m"); - - if (DEBUG_LOGGING) { - const char *id = NULL; - - (void) device_get_device_id(dev, &id); - log_device_debug(dev, "Handling device node '%s', devnum=%s", devnode, strna(id)); - } - /* update possible left-over symlinks */ FOREACH_DEVICE_DEVLINK(dev_old, devlink) { /* check if old link name still belongs to this device */ @@ -558,7 +479,7 @@ int udev_node_update(sd_device *dev, sd_device *dev_old) { return log_device_debug_errno(dev, r, "Failed to get device path: %m"); /* always add /dev/{block,char}/$major:$minor */ - r = node_symlink(dev, devnode, filename); + r = node_symlink(dev, NULL, filename); if (r < 0) return log_device_warning_errno(dev, r, "Failed to create device symlink '%s': %m", filename); diff --git a/src/udev/udev-node.h b/src/udev/udev-node.h index 86a829545a..0c545e4a0f 100644 --- a/src/udev/udev-node.h +++ b/src/udev/udev-node.h @@ -24,5 +24,6 @@ int static_node_apply_permissions( int udev_node_remove(sd_device *dev); int udev_node_update(sd_device *dev, sd_device *dev_old); +int udev_node_cleanup(void); size_t udev_node_escape_path(const char *src, char *dest, size_t size); diff --git a/src/udev/udevd.c b/src/udev/udevd.c index c2a4a8a7bd..40dc36e172 100644 --- a/src/udev/udevd.c +++ b/src/udev/udevd.c @@ -66,6 +66,7 @@ #include "udev-builtin.h" #include "udev-ctrl.h" #include "udev-event.h" +#include "udev-node.h" #include "udev-util.h" #include "udev-watch.h" #include "user-util.h" @@ -112,6 +113,7 @@ typedef struct Manager { usec_t last_usec; + bool udev_node_needs_cleanup; bool stop_exec_queue; bool exit; } Manager; @@ -977,6 +979,9 @@ static int event_queue_start(Manager *manager) { if (!manager->events || manager->exit || manager->stop_exec_queue) return 0; + /* To make the stack directory /run/udev/links cleaned up later. */ + manager->udev_node_needs_cleanup = true; + r = event_source_disable(manager->kill_workers_event); if (r < 0) log_warning_errno(r, "Failed to disable event source for cleaning up idle workers, ignoring: %m"); @@ -1568,6 +1573,11 @@ static int on_post(sd_event_source *s, void *userdata) { /* There are no idle workers. */ + if (manager->udev_node_needs_cleanup) { + (void) udev_node_cleanup(); + manager->udev_node_needs_cleanup = false; + } + if (manager->exit) return sd_event_exit(manager->event, 0);