SymbX/systemd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #23043 from yuwata/udev-node-use-flock

Browse Source 
udev-node: use flock() for symlink stack directory
This commit is contained in:
Yu Watanabe
2022-09-12 23:40:34 +09:00
committed by GitHub
parent 4167e2135e 1055172804
commit 75a5a143bb
6 changed files with 285 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/basic/path-util.c
+18
View File
@@ -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;
src/basic/path-util.h
+1
View File
@@ -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);
src/test/test-path-util.c
+27
View File
@@ -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;
src/udev/udev-node.c
+228 -307
View File
@@ -1,11 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-or-later */
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stddef.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/file.h>
#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);
src/udev/udev-node.h
+1
View File
@@ -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);
src/udev/udevd.c
+10
View File
@@ -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);