1 /*
2 * Copyright (C) 2004-2012 Kay Sievers <kay@vrfy.org>
3 * Copyright (C) 2009 Canonical Ltd.
4 * Copyright (C) 2009 Scott James Remnant <scott@netsplit.com>
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <sys/types.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <stdio.h>
24 #include <dirent.h>
25 #include <stddef.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <sys/inotify.h>
30
31 #include "udev.h"
32
33 static int inotify_fd = -1;
34
35 /* inotify descriptor, will be shared with rules directory;
36 * set to cloexec since we need our children to be able to add
37 * watches for us
38 */
udev_watch_init(struct udev * udev)39 int udev_watch_init(struct udev *udev) {
40 inotify_fd = inotify_init1(IN_CLOEXEC);
41 if (inotify_fd < 0)
42 log_error_errno(errno, "inotify_init failed: %m");
43 return inotify_fd;
44 }
45
46 /* move any old watches directory out of the way, and then restore
47 * the watches
48 */
udev_watch_restore(struct udev * udev)49 void udev_watch_restore(struct udev *udev) {
50 if (inotify_fd < 0)
51 return;
52
53 if (rename(UDEV_ROOT_RUN "/udev/watch", UDEV_ROOT_RUN "/udev/watch.old") == 0) {
54 DIR *dir;
55 struct dirent *ent;
56
57 dir = opendir(UDEV_ROOT_RUN "/udev/watch.old");
58 if (dir == NULL) {
59 log_error_errno(errno, "unable to open old watches dir " UDEV_ROOT_RUN "/udev/watch.old; old watches will not be restored: %m");
60 return;
61 }
62
63 for (ent = readdir(dir); ent != NULL; ent = readdir(dir)) {
64 char device[UTIL_PATH_SIZE];
65 ssize_t len;
66 struct udev_device *dev;
67
68 if (ent->d_name[0] == '.')
69 continue;
70
71 len = readlinkat(dirfd(dir), ent->d_name, device, sizeof(device));
72 if (len <= 0 || len == (ssize_t)sizeof(device))
73 goto unlink;
74 device[len] = '\0';
75
76 dev = udev_device_new_from_device_id(udev, device);
77 if (dev == NULL)
78 goto unlink;
79
80 log_debug("restoring old watch on '%s'", udev_device_get_devnode(dev));
81 udev_watch_begin(udev, dev);
82 udev_device_unref(dev);
83 unlink:
84 unlinkat(dirfd(dir), ent->d_name, 0);
85 }
86
87 closedir(dir);
88 rmdir(UDEV_ROOT_RUN "/udev/watch.old");
89
90 } else if (errno != ENOENT) {
91 log_error_errno(errno, "unable to move watches dir " UDEV_ROOT_RUN "/udev/watch; old watches will not be restored: %m");
92 }
93 }
94
udev_watch_begin(struct udev * udev,struct udev_device * dev)95 void udev_watch_begin(struct udev *udev, struct udev_device *dev) {
96 char filename[UTIL_PATH_SIZE];
97 int wd;
98 int r;
99
100 if (inotify_fd < 0)
101 return;
102
103 log_debug("adding watch on '%s'", udev_device_get_devnode(dev));
104 wd = inotify_add_watch(inotify_fd, udev_device_get_devnode(dev), IN_CLOSE_WRITE);
105 if (wd < 0) {
106 log_error_errno(errno, "inotify_add_watch(%d, %s, %o) failed: %m",
107 inotify_fd, udev_device_get_devnode(dev), IN_CLOSE_WRITE);
108 return;
109 }
110
111 snprintf(filename, sizeof(filename), UDEV_ROOT_RUN "/udev/watch/%d", wd);
112 mkdir_parents(filename, 0755);
113 unlink(filename);
114 r = symlink(udev_device_get_id_filename(dev), filename);
115 if (r < 0)
116 log_error_errno(errno, "Failed to create symlink %s: %m", filename);
117
118 udev_device_set_watch_handle(dev, wd);
119 }
120
udev_watch_end(struct udev * udev,struct udev_device * dev)121 void udev_watch_end(struct udev *udev, struct udev_device *dev) {
122 int wd;
123 char filename[UTIL_PATH_SIZE];
124
125 if (inotify_fd < 0)
126 return;
127
128 wd = udev_device_get_watch_handle(dev);
129 if (wd < 0)
130 return;
131
132 log_debug("removing watch on '%s'", udev_device_get_devnode(dev));
133 inotify_rm_watch(inotify_fd, wd);
134
135 snprintf(filename, sizeof(filename), UDEV_ROOT_RUN "/udev/watch/%d", wd);
136 unlink(filename);
137
138 udev_device_set_watch_handle(dev, -1);
139 }
140
udev_watch_lookup(struct udev * udev,int wd)141 struct udev_device *udev_watch_lookup(struct udev *udev, int wd) {
142 char filename[UTIL_PATH_SIZE];
143 char device[UTIL_NAME_SIZE];
144 ssize_t len;
145
146 if (inotify_fd < 0 || wd < 0)
147 return NULL;
148
149 snprintf(filename, sizeof(filename), UDEV_ROOT_RUN "/udev/watch/%d", wd);
150 len = readlink(filename, device, sizeof(device));
151 if (len <= 0 || (size_t)len == sizeof(device))
152 return NULL;
153 device[len] = '\0';
154
155 return udev_device_new_from_device_id(udev, device);
156 }
157