From 78e278ad48e0d2854f950f261804fde70121820e Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 31 Mar 2022 05:04:56 +0900 Subject: [PATCH] udev: use sd_device_open() where appropriate --- src/udev/udev-builtin-blkid.c | 9 ++++--- src/udev/udev-builtin-input_id.c | 11 ++++---- src/udev/udev-builtin-keyboard.c | 8 +++--- src/udev/udev-node.c | 18 ++++--------- src/udev/udevd.c | 45 ++++++++++++++------------------ 5 files changed, 39 insertions(+), 52 deletions(-) diff --git a/src/udev/udev-builtin-blkid.c b/src/udev/udev-builtin-blkid.c index 586f083ffa7..c30c78fad51 100644 --- a/src/udev/udev-builtin-blkid.c +++ b/src/udev/udev-builtin-blkid.c @@ -302,11 +302,12 @@ static int builtin_blkid(sd_device *dev, sd_netlink **rtnl, int argc, char *argv if (r < 0) return log_device_debug_errno(dev, r, "Failed to get device name: %m"); - fd = open(devnode, O_RDONLY|O_CLOEXEC|O_NONBLOCK); + fd = sd_device_open(dev, O_RDONLY|O_CLOEXEC|O_NONBLOCK); if (fd < 0) { - log_device_debug_errno(dev, errno, "Failed to open block device %s%s: %m", - devnode, errno == ENOENT ? ", ignoring" : ""); - return errno == ENOENT ? 0 : -errno; + bool ignore = ERRNO_IS_DEVICE_ABSENT(fd); + log_device_debug_errno(dev, fd, "Failed to open block device %s%s: %m", + devnode, ignore ? ", ignoring" : ""); + return ignore ? 0 : fd; } errno = 0; diff --git a/src/udev/udev-builtin-input_id.c b/src/udev/udev-builtin-input_id.c index a34f6de6176..55f7d3f44dd 100644 --- a/src/udev/udev-builtin-input_id.c +++ b/src/udev/udev-builtin-input_id.c @@ -45,12 +45,12 @@ static int abs_size_mm(const struct input_absinfo *absinfo) { return (absinfo->maximum - absinfo->minimum) / absinfo->resolution; } -static void extract_info(sd_device *dev, const char *devpath, bool test) { +static void extract_info(sd_device *dev, bool test) { char width[DECIMAL_STR_MAX(int)], height[DECIMAL_STR_MAX(int)]; struct input_absinfo xabsinfo = {}, yabsinfo = {}; _cleanup_close_ int fd = -1; - fd = open(devpath, O_RDONLY|O_CLOEXEC); + fd = sd_device_open(dev, O_RDONLY|O_CLOEXEC|O_NONBLOCK); if (fd < 0) return; @@ -330,7 +330,7 @@ static int builtin_input_id(sd_device *dev, sd_netlink **rtnl, int argc, char *a unsigned long bitmask_key[NBITS(KEY_MAX)]; unsigned long bitmask_rel[NBITS(REL_MAX)]; unsigned long bitmask_props[NBITS(INPUT_PROP_MAX)]; - const char *sysname, *devnode; + const char *sysname; bool is_pointer; bool is_key; @@ -375,10 +375,9 @@ static int builtin_input_id(sd_device *dev, sd_netlink **rtnl, int argc, char *a } - if (sd_device_get_devname(dev, &devnode) >= 0 && - sd_device_get_sysname(dev, &sysname) >= 0 && + if (sd_device_get_sysname(dev, &sysname) >= 0 && startswith(sysname, "event")) - extract_info(dev, devnode, test); + extract_info(dev, test); return 0; } diff --git a/src/udev/udev-builtin-keyboard.c b/src/udev/udev-builtin-keyboard.c index cc266cc6634..b09757bfc2e 100644 --- a/src/udev/udev-builtin-keyboard.c +++ b/src/udev/udev-builtin-keyboard.c @@ -195,9 +195,9 @@ static int builtin_keyboard(sd_device *dev, sd_netlink **rtnl, int argc, char *a } if (fd < 0) { - fd = open(node, O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY); + fd = sd_device_open(dev, O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY); if (fd < 0) - return log_device_error_errno(dev, errno, "Failed to open device '%s': %m", node); + return log_device_error_errno(dev, fd, "Failed to open device '%s': %m", node); } (void) map_keycode(dev, fd, scancode, keycode); @@ -212,9 +212,9 @@ static int builtin_keyboard(sd_device *dev, sd_netlink **rtnl, int argc, char *a } if (fd < 0) { - fd = open(node, O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY); + fd = sd_device_open(dev, O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY); if (fd < 0) - return log_device_error_errno(dev, errno, "Failed to open device '%s': %m", node); + return log_device_error_errno(dev, fd, "Failed to open device '%s': %m", node); } if (has_abs == -1) { diff --git a/src/udev/udev-node.c b/src/udev/udev-node.c index 1824ccef6a5..c3131810416 100644 --- a/src/udev/udev-node.c +++ b/src/udev/udev-node.c @@ -598,7 +598,7 @@ int udev_node_apply_permissions( gid_t gid, OrderedHashmap *seclabel_list) { - const char *devnode, *subsystem, *id = NULL; + const char *devnode, *subsystem; bool apply_mode, apply_uid, apply_gid; _cleanup_close_ int node_fd = -1; struct stat stats; @@ -616,33 +616,25 @@ int udev_node_apply_permissions( r = sd_device_get_devnum(dev, &devnum); if (r < 0) return log_device_debug_errno(dev, r, "Failed to get devnum: %m"); - (void) device_get_device_id(dev, &id); if (streq(subsystem, "block")) mode |= S_IFBLK; else mode |= S_IFCHR; - node_fd = open(devnode, O_PATH|O_NOFOLLOW|O_CLOEXEC); + node_fd = sd_device_open(dev, O_PATH|O_CLOEXEC); if (node_fd < 0) { - if (errno == ENOENT) { - log_device_debug_errno(dev, errno, "Device node %s is missing, skipping handling.", devnode); + if (ERRNO_IS_DEVICE_ABSENT(node_fd)) { + log_device_debug_errno(dev, node_fd, "Device node %s is missing, skipping handling.", devnode); return 0; /* This is necessarily racey, so ignore missing the device */ } - return log_device_debug_errno(dev, errno, "Cannot open node %s: %m", devnode); + return log_device_debug_errno(dev, node_fd, "Cannot open node %s: %m", devnode); } if (fstat(node_fd, &stats) < 0) return log_device_debug_errno(dev, errno, "cannot stat() node %s: %m", devnode); - if ((mode != MODE_INVALID && (stats.st_mode & S_IFMT) != (mode & S_IFMT)) || stats.st_rdev != devnum) { - log_device_debug(dev, "Found node '%s' with non-matching devnum %s, skipping handling.", - devnode, strna(id)); - return 0; /* We might process a device that already got replaced by the time we have a look - * at it, handle this gracefully and step away. */ - } - apply_mode = mode != MODE_INVALID && (stats.st_mode & 0777) != (mode & 0777); apply_uid = uid_is_valid(uid) && stats.st_uid != uid; apply_gid = gid_is_valid(gid) && stats.st_gid != gid; diff --git a/src/udev/udevd.c b/src/udev/udevd.c index 424ecfc2cfb..4a37a769247 100644 --- a/src/udev/udevd.c +++ b/src/udev/udevd.c @@ -422,12 +422,11 @@ static int worker_send_result(Manager *manager, int result) { return loop_write(manager->worker_watch[WRITE_END], &result, sizeof(result), false); } -static int device_get_whole_disk(sd_device *dev, const char **ret) { +static int device_get_whole_disk(sd_device *dev, sd_device **ret_device, const char **ret_devname) { const char *val; int r; assert(dev); - assert(ret); if (device_for_action(dev, SD_DEVICE_REMOVE)) goto irrelevant; @@ -463,16 +462,23 @@ static int device_get_whole_disk(sd_device *dev, const char **ret) { if (r < 0) return log_device_debug_errno(dev, r, "Failed to get devname: %m"); - *ret = val; + if (ret_device) + *ret_device = dev; + if (ret_devname) + *ret_devname = val; return 1; irrelevant: - *ret = NULL; + if (ret_device) + *ret_device = NULL; + if (ret_devname) + *ret_devname = NULL; return 0; } static int worker_lock_whole_disk(sd_device *dev, int *ret_fd) { _cleanup_close_ int fd = -1; + sd_device *dev_whole_disk; const char *val; int r; @@ -484,19 +490,19 @@ static int worker_lock_whole_disk(sd_device *dev, int *ret_fd) { * event handling; in the case udev acquired the lock, the external process can block until udev has * finished its event handling. */ - r = device_get_whole_disk(dev, &val); + r = device_get_whole_disk(dev, &dev_whole_disk, &val); if (r < 0) return r; if (r == 0) goto nolock; - fd = open(val, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK); + fd = sd_device_open(dev_whole_disk, O_RDONLY|O_CLOEXEC|O_NONBLOCK); if (fd < 0) { - bool ignore = ERRNO_IS_DEVICE_ABSENT(errno); + bool ignore = ERRNO_IS_DEVICE_ABSENT(fd); - log_device_debug_errno(dev, errno, "Failed to open '%s'%s: %m", val, ignore ? ", ignoring" : ""); + log_device_debug_errno(dev, fd, "Failed to open '%s'%s: %m", val, ignore ? ", ignoring" : ""); if (!ignore) - return -errno; + return fd; goto nolock; } @@ -545,15 +551,9 @@ static int worker_mark_block_device_read_only(sd_device *dev) { if (STARTSWITH_SET(val, "dm-", "md", "drbd", "loop", "nbd", "zram")) return 0; - r = sd_device_get_devname(dev, &val); - if (r == -ENOENT) - return 0; - if (r < 0) - return log_device_debug_errno(dev, r, "Failed to get devname: %m"); - - fd = open(val, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK); + fd = sd_device_open(dev, O_RDONLY|O_CLOEXEC|O_NONBLOCK); if (fd < 0) - return log_device_debug_errno(dev, errno, "Failed to open '%s', ignoring: %m", val); + return log_device_debug_errno(dev, fd, "Failed to open '%s', ignoring: %m", val); if (ioctl(fd, BLKROSET, &state) < 0) return log_device_warning_errno(dev, errno, "Failed to mark block device '%s' read-only: %m", val); @@ -1093,7 +1093,7 @@ static int event_queue_assume_block_device_unlocked(Manager *manager, sd_device * device is not locked anymore. The assumption may not be true, but that should not cause any * issues, as in that case events will be requeued soon. */ - r = device_get_whole_disk(dev, &devname); + r = device_get_whole_disk(dev, NULL, &devname); if (r <= 0) return r; @@ -1106,7 +1106,7 @@ static int event_queue_assume_block_device_unlocked(Manager *manager, sd_device if (event->retry_again_next_usec == 0) continue; - if (device_get_whole_disk(event->dev, &event_devname) <= 0) + if (device_get_whole_disk(event->dev, NULL, &event_devname) <= 0) continue; if (!streq(devname, event_devname)) @@ -1403,18 +1403,13 @@ static int synthesize_change(sd_device *dev) { !startswith(sysname, "dm-")) { _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL; bool part_table_read = false, has_partitions = false; - const char *devname; sd_device *d; int fd; - r = sd_device_get_devname(dev, &devname); - if (r < 0) - return r; - /* Try to re-read the partition table. This only succeeds if none of the devices is * busy. The kernel returns 0 if no partition table is found, and we will not get an * event for the disk. */ - fd = open(devname, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK); + fd = sd_device_open(dev, O_RDONLY|O_CLOEXEC|O_NONBLOCK); if (fd >= 0) { r = flock(fd, LOCK_EX|LOCK_NB); if (r >= 0) -- 2.47.3