chiark / gitweb /
Merge branch 'master' of ssh://git.freedesktop.org/git/systemd/systemd
[elogind.git] / src / udev / udevadm-settle.c
1 /*
2  * Copyright (C) 2006-2009 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 <stdlib.h>
21 #include <stddef.h>
22 #include <string.h>
23 #include <stdio.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <dirent.h>
27 #include <fcntl.h>
28 #include <syslog.h>
29 #include <getopt.h>
30 #include <signal.h>
31 #include <time.h>
32 #include <sys/inotify.h>
33 #include <sys/poll.h>
34 #include <sys/stat.h>
35 #include <sys/types.h>
36
37 #include "udev.h"
38
39 static int adm_settle(struct udev *udev, int argc, char *argv[])
40 {
41         static const struct option options[] = {
42                 { "seq-start", required_argument, NULL, 's' },
43                 { "seq-end", required_argument, NULL, 'e' },
44                 { "timeout", required_argument, NULL, 't' },
45                 { "exit-if-exists", required_argument, NULL, 'E' },
46                 { "quiet", no_argument, NULL, 'q' },
47                 { "help", no_argument, NULL, 'h' },
48                 {}
49         };
50         unsigned long long start_usec = now_usec();
51         unsigned long long start = 0;
52         unsigned long long end = 0;
53         int quiet = 0;
54         const char *exists = NULL;
55         unsigned int timeout = 120;
56         struct pollfd pfd[1];
57         struct udev_queue *udev_queue = NULL;
58         int rc = EXIT_FAILURE;
59
60         dbg(udev, "version %s\n", VERSION);
61
62         for (;;) {
63                 int option;
64                 int seconds;
65
66                 option = getopt_long(argc, argv, "s:e:t:E:qh", options, NULL);
67                 if (option == -1)
68                         break;
69
70                 switch (option) {
71                 case 's':
72                         start = strtoull(optarg, NULL, 0);
73                         break;
74                 case 'e':
75                         end = strtoull(optarg, NULL, 0);
76                         break;
77                 case 't':
78                         seconds = atoi(optarg);
79                         if (seconds >= 0)
80                                 timeout = seconds;
81                         else
82                                 fprintf(stderr, "invalid timeout value\n");
83                         dbg(udev, "timeout=%i\n", timeout);
84                         break;
85                 case 'q':
86                         quiet = 1;
87                         break;
88                 case 'E':
89                         exists = optarg;
90                         break;
91                 case 'h':
92                         printf("Usage: udevadm settle OPTIONS\n"
93                                "  --timeout=<seconds>     maximum time to wait for events\n"
94                                "  --seq-start=<seqnum>    first seqnum to wait for\n"
95                                "  --seq-end=<seqnum>      last seqnum to wait for\n"
96                                "  --exit-if-exists=<file> stop waiting if file exists\n"
97                                "  --quiet                 do not print list after timeout\n"
98                                "  --help\n\n");
99                         exit(EXIT_SUCCESS);
100                 default:
101                         exit(EXIT_FAILURE);
102                 }
103         }
104
105         udev_queue = udev_queue_new(udev);
106         if (udev_queue == NULL)
107                 exit(2);
108
109         if (start > 0) {
110                 unsigned long long kernel_seq;
111
112                 kernel_seq = udev_queue_get_kernel_seqnum(udev_queue);
113
114                 /* unless specified, the last event is the current kernel seqnum */
115                 if (end == 0)
116                         end = udev_queue_get_kernel_seqnum(udev_queue);
117
118                 if (start > end) {
119                         err(udev, "seq-start larger than seq-end, ignoring\n");
120                         start = 0;
121                         end = 0;
122                 }
123
124                 if (start > kernel_seq || end > kernel_seq) {
125                         err(udev, "seq-start or seq-end larger than current kernel value, ignoring\n");
126                         start = 0;
127                         end = 0;
128                 }
129                 info(udev, "start=%llu end=%llu current=%llu\n", start, end, kernel_seq);
130         } else {
131                 if (end > 0) {
132                         err(udev, "seq-end needs seq-start parameter, ignoring\n");
133                         end = 0;
134                 }
135         }
136
137         /* guarantee that the udev daemon isn't pre-processing */
138         if (getuid() == 0) {
139                 struct udev_ctrl *uctrl;
140
141                 uctrl = udev_ctrl_new(udev);
142                 if (uctrl != NULL) {
143                         if (udev_ctrl_send_ping(uctrl, timeout) < 0) {
144                                 info(udev, "no connection to daemon\n");
145                                 udev_ctrl_unref(uctrl);
146                                 rc = EXIT_SUCCESS;
147                                 goto out;
148                         }
149                         udev_ctrl_unref(uctrl);
150                 }
151         }
152
153         pfd[0].events = POLLIN;
154         pfd[0].fd = inotify_init1(IN_CLOEXEC);
155         if (pfd[0].fd < 0) {
156                 err(udev, "inotify_init failed: %m\n");
157         } else {
158                 if (inotify_add_watch(pfd[0].fd, udev_get_run_path(udev), IN_MOVED_TO) < 0) {
159                         err(udev, "watching '%s' failed\n", udev_get_run_path(udev));
160                         close(pfd[0].fd);
161                         pfd[0].fd = -1;
162                 }
163         }
164
165         for (;;) {
166                 struct stat statbuf;
167
168                 if (exists != NULL && stat(exists, &statbuf) == 0) {
169                         rc = EXIT_SUCCESS;
170                         break;
171                 }
172
173                 if (start > 0) {
174                         /* if asked for, wait for a specific sequence of events */
175                         if (udev_queue_get_seqnum_sequence_is_finished(udev_queue, start, end) == 1) {
176                                 rc = EXIT_SUCCESS;
177                                 break;
178                         }
179                 } else {
180                         /* exit if queue is empty */
181                         if (udev_queue_get_queue_is_empty(udev_queue)) {
182                                 rc = EXIT_SUCCESS;
183                                 break;
184                         }
185                 }
186
187                 if (pfd[0].fd >= 0) {
188                         int delay;
189
190                         if (exists != NULL || start > 0)
191                                 delay = 100;
192                         else
193                                 delay = 1000;
194                         /* wake up after delay, or immediately after the queue is rebuilt */
195                         if (poll(pfd, 1, delay) > 0 && pfd[0].revents & POLLIN) {
196                                 char buf[sizeof(struct inotify_event) + PATH_MAX];
197
198                                 read(pfd[0].fd, buf, sizeof(buf));
199                         }
200                 } else {
201                         sleep(1);
202                 }
203
204                 if (timeout > 0) {
205                         unsigned long long age_usec;
206
207                         age_usec = now_usec() - start_usec;
208                         if (age_usec / (1000 * 1000) >= timeout) {
209                                 struct udev_list_entry *list_entry;
210
211                                 if (!quiet && udev_queue_get_queued_list_entry(udev_queue) != NULL) {
212                                         info(udev, "timeout waiting for udev queue\n");
213                                         printf("\nudevadm settle - timeout of %i seconds reached, the event queue contains:\n", timeout);
214                                         udev_list_entry_foreach(list_entry, udev_queue_get_queued_list_entry(udev_queue))
215                                                 printf("  %s (%s)\n",
216                                                 udev_list_entry_get_name(list_entry),
217                                                 udev_list_entry_get_value(list_entry));
218                                 }
219
220                                 break;
221                         }
222                 }
223         }
224 out:
225         if (pfd[0].fd >= 0)
226                 close(pfd[0].fd);
227         udev_queue_unref(udev_queue);
228         return rc;
229 }
230
231 const struct udevadm_cmd udevadm_settle = {
232         .name = "settle",
233         .cmd = adm_settle,
234         .help = "wait for the event queue to finish",
235 };