chiark / gitweb /
test: make it easier to override kernel version
[elogind.git] / src / udev / udev-watch.c
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  */
39 int udev_watch_init(struct udev *udev)
40 {
41         inotify_fd = inotify_init1(IN_CLOEXEC);
42         if (inotify_fd < 0)
43                 log_error("inotify_init failed: %m\n");
44         return inotify_fd;
45 }
46
47 /* move any old watches directory out of the way, and then restore
48  * the watches
49  */
50 void udev_watch_restore(struct udev *udev)
51 {
52         if (inotify_fd < 0)
53                 return;
54
55         if (rename("/run/udev/watch", "/run/udev/watch.old") == 0) {
56                 DIR *dir;
57                 struct dirent *ent;
58
59                 dir = opendir("/run/udev/watch.old");
60                 if (dir == NULL) {
61                         log_error("unable to open old watches dir /run/udev/watch.old; old watches will not be restored: %m");
62                         return;
63                 }
64
65                 for (ent = readdir(dir); ent != NULL; ent = readdir(dir)) {
66                         char device[UTIL_PATH_SIZE];
67                         ssize_t len;
68                         struct udev_device *dev;
69
70                         if (ent->d_name[0] == '.')
71                                 continue;
72
73                         len = readlinkat(dirfd(dir), ent->d_name, device, sizeof(device));
74                         if (len <= 0 || len == (ssize_t)sizeof(device))
75                                 goto unlink;
76                         device[len] = '\0';
77
78                         dev = udev_device_new_from_device_id(udev, device);
79                         if (dev == NULL)
80                                 goto unlink;
81
82                         log_debug("restoring old watch on '%s'\n", udev_device_get_devnode(dev));
83                         udev_watch_begin(udev, dev);
84                         udev_device_unref(dev);
85 unlink:
86                         unlinkat(dirfd(dir), ent->d_name, 0);
87                 }
88
89                 closedir(dir);
90                 rmdir("/run/udev/watch.old");
91
92         } else if (errno != ENOENT) {
93                 log_error("unable to move watches dir /run/udev/watch; old watches will not be restored: %m");
94         }
95 }
96
97 void udev_watch_begin(struct udev *udev, struct udev_device *dev)
98 {
99         char filename[UTIL_PATH_SIZE];
100         int wd;
101         int r;
102
103         if (inotify_fd < 0)
104                 return;
105
106         log_debug("adding watch on '%s'\n", udev_device_get_devnode(dev));
107         wd = inotify_add_watch(inotify_fd, udev_device_get_devnode(dev), IN_CLOSE_WRITE);
108         if (wd < 0) {
109                 log_error("inotify_add_watch(%d, %s, %o) failed: %m\n",
110                     inotify_fd, udev_device_get_devnode(dev), IN_CLOSE_WRITE);
111                 return;
112         }
113
114         snprintf(filename, sizeof(filename), "/run/udev/watch/%d", wd);
115         mkdir_parents(filename, 0755);
116         unlink(filename);
117         r = symlink(udev_device_get_id_filename(dev), filename);
118         if (r < 0)
119                 log_error("Failed to create symlink: %m");
120
121         udev_device_set_watch_handle(dev, wd);
122 }
123
124 void udev_watch_end(struct udev *udev, struct udev_device *dev)
125 {
126         int wd;
127         char filename[UTIL_PATH_SIZE];
128
129         if (inotify_fd < 0)
130                 return;
131
132         wd = udev_device_get_watch_handle(dev);
133         if (wd < 0)
134                 return;
135
136         log_debug("removing watch on '%s'\n", udev_device_get_devnode(dev));
137         inotify_rm_watch(inotify_fd, wd);
138
139         snprintf(filename, sizeof(filename), "/run/udev/watch/%d", wd);
140         unlink(filename);
141
142         udev_device_set_watch_handle(dev, -1);
143 }
144
145 struct udev_device *udev_watch_lookup(struct udev *udev, int wd)
146 {
147         char filename[UTIL_PATH_SIZE];
148         char device[UTIL_NAME_SIZE];
149         ssize_t len;
150
151         if (inotify_fd < 0 || wd < 0)
152                 return NULL;
153
154         snprintf(filename, sizeof(filename), "/run/udev/watch/%d", wd);
155         len = readlink(filename, device, sizeof(device));
156         if (len <= 0 || (size_t)len == sizeof(device))
157                 return NULL;
158         device[len] = '\0';
159
160         return udev_device_new_from_device_id(udev, device);
161 }