udev: use sd_device_open() where appropriate

diff --git a/src/udev/udev-builtin-blkid.c b/src/udev/udev-builtin-blkid.c
index 586f083ffa741412fb7513823f5f05a0db453820..c30c78fad5184592c475e6011214104def370db5 100644 (file)
--- 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 a34f6de6176bfd071746c934d847387ac7959663..55f7d3f44ddf98f2ae1ebc2a5eec9cc7a1ed1c8d 100644 (file)
--- 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 cc266cc6634d508da342678746a574e6196cede5..b09757bfc2ea32e90f17a46972f09f90f612fcdb 100644 (file)
--- 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 1824ccef6a505177bbf95d6d88a8c1df77061ee7..c313181041660edd92fed79f95b17a20c23c8130 100644 (file)
--- 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 424ecfc2cfb7eb267443a47bb07510bf0b888311..4a37a769247465296fa75049a3ec3b366077c790 100644 (file)
--- 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)