src/udev/udev-watch.c

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Copyright © 2009 Canonical Ltd.
   4  * Copyright © 2009 Scott James Remnant <scott@netsplit.com>
   5  */
   6
   7 #include <sys/inotify.h>
   8 #include <unistd.h>
   9
  10 #include "alloc-util.h"
  11 #include "device-private.h"
  12 #include "device-util.h"
  13 #include "dirent-util.h"
  14 #include "fs-util.h"
  15 #include "mkdir.h"
  16 #include "stdio-util.h"
  17 #include "udev-watch.h"
  18
  19 static int inotify_fd = -1;
  20
  21 /* inotify descriptor, will be shared with rules directory;
  22  * set to cloexec since we need our children to be able to add
  23  * watches for us. */
  24 int udev_watch_init(void) {
  25         inotify_fd = inotify_init1(IN_CLOEXEC);
  26         if (inotify_fd < 0)
  27                 return -errno;
  28
  29         return inotify_fd;
  30 }
  31
  32 /* Move any old watches directory out of the way, and then restore the watches. */
  33 int udev_watch_restore(void) {
  34         struct dirent *ent;
  35         DIR *dir;
  36         int r;
  37
  38         if (inotify_fd < 0)
  39                 return log_debug_errno(EINVAL, "Invalid inotify descriptor.");
  40
  41         if (rename("/run/udev/watch", "/run/udev/watch.old") < 0) {
  42                 if (errno != ENOENT)
  43                         return log_warning_errno(errno, "Failed to move watches directory /run/udev/watch. Old watches will not be restored: %m");
  44
  45                 return 0;
  46         }
  47
  48         dir = opendir("/run/udev/watch.old");
  49         if (!dir)
  50                 return log_warning_errno(errno, "Failed to open old watches directory /run/udev/watch.old. Old watches will not be restored: %m");
  51
  52         FOREACH_DIRENT_ALL(ent, dir, break) {
  53                 _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
  54                 _cleanup_free_ char *device = NULL;
  55
  56                 if (ent->d_name[0] == '.')
  57                         continue;
  58
  59                 r = readlinkat_malloc(dirfd(dir), ent->d_name, &device);
  60                 if (r < 0) {
  61                         log_debug_errno(r, "Failed to read link '/run/udev/watch.old/%s', ignoring: %m", ent->d_name);
  62                         goto unlink;
  63                 }
  64
  65                 r = sd_device_new_from_device_id(&dev, device);
  66                 if (r < 0) {
  67                         log_debug_errno(r, "Failed to create sd_device object for '%s', ignoring: %m", device);
  68                         goto unlink;
  69                 }
  70
  71                 log_device_debug(dev, "Restoring old watch");
  72                 (void) udev_watch_begin(dev);
  73 unlink:
  74                 (void) unlinkat(dirfd(dir), ent->d_name, 0);
  75         }
  76
  77         (void) closedir(dir);
  78         (void) rmdir("/run/udev/watch.old");
  79
  80         return 0;
  81 }
  82
  83 int udev_watch_begin(sd_device *dev) {
  84         char filename[STRLEN("/run/udev/watch/") + DECIMAL_STR_MAX(int)];
  85         const char *devnode, *id_filename;
  86         int wd, r;
  87
  88         if (inotify_fd < 0)
  89                 return log_debug_errno(EINVAL, "Invalid inotify descriptor.");
  90
  91         r = sd_device_get_devname(dev, &devnode);
  92         if (r < 0)
  93                 return log_device_error_errno(dev, r, "Failed to get device name: %m");
  94
  95         log_device_debug(dev, "Adding watch on '%s'", devnode);
  96         wd = inotify_add_watch(inotify_fd, devnode, IN_CLOSE_WRITE);
  97         if (wd < 0)
  98                 return log_device_full(dev,
  99                                        errno == ENOENT ? LOG_DEBUG : LOG_ERR,
 100                                        errno,
 101                                        "Failed to add device '%s' to watch: %m", devnode);
 102
 103         device_set_watch_handle(dev, wd);
 104
 105         xsprintf(filename, "/run/udev/watch/%d", wd);
 106         r = mkdir_parents(filename, 0755);
 107         if (r < 0)
 108                 return log_device_error_errno(dev, r, "Failed to create parent directory of '%s': %m", filename);
 109         (void) unlink(filename);
 110
 111         r = device_get_id_filename(dev, &id_filename);
 112         if (r < 0)
 113                 return log_device_error_errno(dev, r, "Failed to get device id-filename: %m");
 114
 115         if (symlink(id_filename, filename) < 0)
 116                 return log_device_error_errno(dev, errno, "Failed to create symlink %s: %m", filename);
 117
 118         return 0;
 119 }
 120
 121 int udev_watch_end(sd_device *dev) {
 122         char filename[STRLEN("/run/udev/watch/") + DECIMAL_STR_MAX(int)];
 123         int wd, r;
 124
 125         if (inotify_fd < 0)
 126                 return log_debug_errno(EINVAL, "Invalid inotify descriptor.");
 127
 128         r = device_get_watch_handle(dev, &wd);
 129         if (r == -ENOENT)
 130                 return 0;
 131         if (r < 0)
 132                 return log_device_debug_errno(dev, r, "Failed to get watch handle, ignoring: %m");
 133
 134         log_device_debug(dev, "Removing watch");
 135         (void) inotify_rm_watch(inotify_fd, wd);
 136
 137         xsprintf(filename, "/run/udev/watch/%d", wd);
 138         (void) unlink(filename);
 139
 140         device_set_watch_handle(dev, -1);
 141
 142         return 0;
 143 }
 144
 145 int udev_watch_lookup(int wd, sd_device **ret) {
 146         char filename[STRLEN("/run/udev/watch/") + DECIMAL_STR_MAX(int)];
 147         _cleanup_free_ char *device = NULL;
 148         int r;
 149
 150         assert(ret);
 151
 152         if (inotify_fd < 0)
 153                 return log_debug_errno(EINVAL, "Invalid inotify descriptor.");
 154
 155         if (wd < 0)
 156                 return log_debug_errno(EINVAL, "Invalid watch handle.");
 157
 158         xsprintf(filename, "/run/udev/watch/%d", wd);
 159         r = readlink_malloc(filename, &device);
 160         if (r == -ENOENT)
 161                 return 0;
 162         if (r < 0)
 163                 return log_debug_errno(r, "Failed to read link '%s': %m", filename);
 164
 165         r = sd_device_new_from_device_id(ret, device);
 166         if (r == -ENODEV)
 167                 return 0;
 168         if (r < 0)
 169                 return log_debug_errno(r, "Failed to create sd_device object for '%s': %m", device);
 170
 171         return 1;
 172 }