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