]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/udev/udevd.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
udevd: make worker_process_device() take sd_device instead of udev_device
[thirdparty/systemd.git] / src / udev / udevd.c
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3 * Copyright © 2004 Chris Friesen <chris_friesen@sympatico.ca>
4 * Copyright © 2009 Canonical Ltd.
5 * Copyright © 2009 Scott James Remnant <scott@netsplit.com>
6 */
7
8 #include <errno.h>
9 #include <fcntl.h>
10 #include <getopt.h>
11 #include <signal.h>
12 #include <stdbool.h>
13 #include <stddef.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <sys/epoll.h>
18 #include <sys/file.h>
19 #include <sys/inotify.h>
20 #include <sys/ioctl.h>
21 #include <sys/mount.h>
22 #include <sys/prctl.h>
23 #include <sys/signalfd.h>
24 #include <sys/socket.h>
25 #include <sys/stat.h>
26 #include <sys/time.h>
27 #include <sys/wait.h>
28 #include <unistd.h>
29
30 #include "sd-daemon.h"
31 #include "sd-event.h"
32
33 #include "alloc-util.h"
34 #include "cgroup-util.h"
35 #include "cpu-set-util.h"
36 #include "dev-setup.h"
37 #include "device-private.h"
38 #include "device-util.h"
39 #include "event-util.h"
40 #include "fd-util.h"
41 #include "fileio.h"
42 #include "format-util.h"
43 #include "fs-util.h"
44 #include "hashmap.h"
45 #include "io-util.h"
46 #include "libudev-device-internal.h"
47 #include "list.h"
48 #include "netlink-util.h"
49 #include "parse-util.h"
50 #include "proc-cmdline.h"
51 #include "process-util.h"
52 #include "selinux-util.h"
53 #include "signal-util.h"
54 #include "socket-util.h"
55 #include "string-util.h"
56 #include "syslog-util.h"
57 #include "terminal-util.h"
58 #include "udev-builtin.h"
59 #include "udev-ctrl.h"
60 #include "udev-util.h"
61 #include "udev-watch.h"
62 #include "udev.h"
63 #include "user-util.h"
64
65 static bool arg_debug = false;
66 static int arg_daemonize = false;
67 static ResolveNameTiming arg_resolve_name_timing = RESOLVE_NAME_EARLY;
68 static unsigned arg_children_max = 0;
69 static usec_t arg_exec_delay_usec = 0;
70 static usec_t arg_event_timeout_usec = 180 * USEC_PER_SEC;
71
72 typedef struct Manager {
73 sd_event *event;
74 Hashmap *workers;
75 LIST_HEAD(struct event, events);
76 const char *cgroup;
77 pid_t pid; /* the process that originally allocated the manager object */
78
79 struct udev_rules *rules;
80 Hashmap *properties;
81
82 sd_netlink *rtnl;
83
84 struct udev_monitor *monitor;
85 struct udev_ctrl *ctrl;
86 struct udev_ctrl_connection *ctrl_conn_blocking;
87 int fd_inotify;
88 int worker_watch[2];
89
90 sd_event_source *ctrl_event;
91 sd_event_source *uevent_event;
92 sd_event_source *inotify_event;
93 sd_event_source *kill_workers_event;
94
95 usec_t last_usec;
96
97 bool stop_exec_queue:1;
98 bool exit:1;
99 } Manager;
100
101 enum event_state {
102 EVENT_UNDEF,
103 EVENT_QUEUED,
104 EVENT_RUNNING,
105 };
106
107 struct event {
108 LIST_FIELDS(struct event, event);
109 Manager *manager;
110 struct udev_device *dev;
111 struct udev_device *dev_kernel;
112 struct worker *worker;
113 enum event_state state;
114 unsigned long long int delaying_seqnum;
115 unsigned long long int seqnum;
116 const char *devpath;
117 size_t devpath_len;
118 const char *devpath_old;
119 dev_t devnum;
120 int ifindex;
121 bool is_block;
122 sd_event_source *timeout_warning;
123 sd_event_source *timeout;
124 };
125
126 static void event_queue_cleanup(Manager *manager, enum event_state type);
127
128 enum worker_state {
129 WORKER_UNDEF,
130 WORKER_RUNNING,
131 WORKER_IDLE,
132 WORKER_KILLED,
133 };
134
135 struct worker {
136 Manager *manager;
137 pid_t pid;
138 struct udev_monitor *monitor;
139 enum worker_state state;
140 struct event *event;
141 };
142
143 /* passed from worker to main process */
144 struct worker_message {
145 };
146
147 static void event_free(struct event *event) {
148 int r;
149
150 if (!event)
151 return;
152 assert(event->manager);
153
154 LIST_REMOVE(event, event->manager->events, event);
155 udev_device_unref(event->dev);
156 udev_device_unref(event->dev_kernel);
157
158 sd_event_source_unref(event->timeout_warning);
159 sd_event_source_unref(event->timeout);
160
161 if (event->worker)
162 event->worker->event = NULL;
163
164 if (LIST_IS_EMPTY(event->manager->events)) {
165 /* only clean up the queue from the process that created it */
166 if (event->manager->pid == getpid_cached()) {
167 r = unlink("/run/udev/queue");
168 if (r < 0)
169 log_warning_errno(errno, "could not unlink /run/udev/queue: %m");
170 }
171 }
172
173 free(event);
174 }
175
176 static void worker_free(struct worker *worker) {
177 if (!worker)
178 return;
179
180 assert(worker->manager);
181
182 hashmap_remove(worker->manager->workers, PID_TO_PTR(worker->pid));
183 udev_monitor_unref(worker->monitor);
184 event_free(worker->event);
185
186 free(worker);
187 }
188
189 static void manager_workers_free(Manager *manager) {
190 struct worker *worker;
191 Iterator i;
192
193 assert(manager);
194
195 HASHMAP_FOREACH(worker, manager->workers, i)
196 worker_free(worker);
197
198 manager->workers = hashmap_free(manager->workers);
199 }
200
201 static int worker_new(struct worker **ret, Manager *manager, struct udev_monitor *worker_monitor, pid_t pid) {
202 _cleanup_free_ struct worker *worker = NULL;
203 int r;
204
205 assert(ret);
206 assert(manager);
207 assert(worker_monitor);
208 assert(pid > 1);
209
210 worker = new0(struct worker, 1);
211 if (!worker)
212 return -ENOMEM;
213
214 worker->manager = manager;
215 /* close monitor, but keep address around */
216 udev_monitor_disconnect(worker_monitor);
217 worker->monitor = udev_monitor_ref(worker_monitor);
218 worker->pid = pid;
219
220 r = hashmap_ensure_allocated(&manager->workers, NULL);
221 if (r < 0)
222 return r;
223
224 r = hashmap_put(manager->workers, PID_TO_PTR(pid), worker);
225 if (r < 0)
226 return r;
227
228 *ret = TAKE_PTR(worker);
229
230 return 0;
231 }
232
233 static int on_event_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
234 struct event *event = userdata;
235
236 assert(event);
237 assert(event->worker);
238
239 kill_and_sigcont(event->worker->pid, SIGKILL);
240 event->worker->state = WORKER_KILLED;
241
242 log_error("seq %llu '%s' killed", udev_device_get_seqnum(event->dev), event->devpath);
243
244 return 1;
245 }
246
247 static int on_event_timeout_warning(sd_event_source *s, uint64_t usec, void *userdata) {
248 struct event *event = userdata;
249
250 assert(event);
251
252 log_warning("seq %llu '%s' is taking a long time", udev_device_get_seqnum(event->dev), event->devpath);
253
254 return 1;
255 }
256
257 static void worker_attach_event(struct worker *worker, struct event *event) {
258 sd_event *e;
259 uint64_t usec;
260
261 assert(worker);
262 assert(worker->manager);
263 assert(event);
264 assert(!event->worker);
265 assert(!worker->event);
266
267 worker->state = WORKER_RUNNING;
268 worker->event = event;
269 event->state = EVENT_RUNNING;
270 event->worker = worker;
271
272 e = worker->manager->event;
273
274 assert_se(sd_event_now(e, CLOCK_MONOTONIC, &usec) >= 0);
275
276 (void) sd_event_add_time(e, &event->timeout_warning, CLOCK_MONOTONIC,
277 usec + udev_warn_timeout(arg_event_timeout_usec), USEC_PER_SEC, on_event_timeout_warning, event);
278
279 (void) sd_event_add_time(e, &event->timeout, CLOCK_MONOTONIC,
280 usec + arg_event_timeout_usec, USEC_PER_SEC, on_event_timeout, event);
281 }
282
283 static void manager_clear_for_worker(Manager *manager) {
284 assert(manager);
285
286 manager->ctrl_event = sd_event_source_unref(manager->ctrl_event);
287 manager->uevent_event = sd_event_source_unref(manager->uevent_event);
288 manager->inotify_event = sd_event_source_unref(manager->inotify_event);
289 manager->kill_workers_event = sd_event_source_unref(manager->kill_workers_event);
290
291 manager->event = sd_event_unref(manager->event);
292
293 manager_workers_free(manager);
294 event_queue_cleanup(manager, EVENT_UNDEF);
295
296 manager->monitor = udev_monitor_unref(manager->monitor);
297 manager->ctrl_conn_blocking = udev_ctrl_connection_unref(manager->ctrl_conn_blocking);
298 manager->ctrl = udev_ctrl_unref(manager->ctrl);
299
300 manager->worker_watch[READ_END] = safe_close(manager->worker_watch[READ_END]);
301 }
302
303 static void manager_free(Manager *manager) {
304 if (!manager)
305 return;
306
307 udev_builtin_exit();
308
309 manager_clear_for_worker(manager);
310
311 sd_netlink_unref(manager->rtnl);
312
313 hashmap_free_free_free(manager->properties);
314 udev_rules_unref(manager->rules);
315
316 safe_close(manager->fd_inotify);
317 safe_close_pair(manager->worker_watch);
318
319 free(manager);
320 }
321
322 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
323
324 static int worker_send_message(int fd) {
325 struct worker_message message = {};
326
327 return loop_write(fd, &message, sizeof(message), false);
328 }
329
330 static int worker_lock_block_device(sd_device *dev, int *ret_fd) {
331 _cleanup_close_ int fd = -1;
332 const char *val;
333 int r;
334
335 assert(dev);
336 assert(ret_fd);
337
338 /*
339 * Take a shared lock on the device node; this establishes
340 * a concept of device "ownership" to serialize device
341 * access. External processes holding an exclusive lock will
342 * cause udev to skip the event handling; in the case udev
343 * acquired the lock, the external process can block until
344 * udev has finished its event handling.
345 */
346
347 r = sd_device_get_property_value(dev, "ACTION", &val);
348 if (r < 0)
349 return log_device_debug_errno(dev, r, "Failed to get the value of property 'ACTION': %m");
350
351 if (streq(val, "remove"))
352 return 0;
353
354 r = sd_device_get_subsystem(dev, &val);
355 if (r < 0)
356 return log_device_debug_errno(dev, r, "Failed to get subsystem: %m");
357
358 if (!streq(val, "block"))
359 return 0;
360
361 r = sd_device_get_sysname(dev, &val);
362 if (r < 0)
363 return log_device_debug_errno(dev, r, "Failed to get sysname: %m");
364
365 if (startswith(val, "dm-") ||
366 startswith(val, "md") ||
367 startswith(val, "drbd"))
368 return 0;
369
370 r = sd_device_get_devtype(dev, &val);
371 if (r < 0 && r != -ENOENT)
372 return log_device_debug_errno(dev, r, "Failed to get devtype: %m");
373 if (r >= 0 && streq(val, "partition")) {
374 r = sd_device_get_parent(dev, &dev);
375 if (r < 0)
376 return log_device_debug_errno(dev, r, "Failed to get parent device: %m");
377 }
378
379 r = sd_device_get_devname(dev, &val);
380 if (r == -ENOENT)
381 return 0;
382 if (r < 0)
383 return log_device_debug_errno(dev, r, "Failed to get devname: %m");
384
385 fd = open(val, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK);
386 if (fd < 0) {
387 log_device_debug_errno(dev, errno, "Failed to open '%s', ignoring: %m", val);
388 return 0;
389 }
390
391 if (flock(fd, LOCK_SH|LOCK_NB) < 0)
392 return log_device_debug_errno(dev, errno, "Failed to flock(%s): %m", val);
393
394 *ret_fd = TAKE_FD(fd);
395 return 1;
396 }
397
398 static int worker_process_device(Manager *manager, sd_device *dev) {
399 _cleanup_(udev_event_freep) struct udev_event *udev_event = NULL;
400 _cleanup_close_ int fd_lock = -1;
401 const char *seqnum;
402 int r;
403
404 assert(manager);
405 assert(dev);
406
407 r = sd_device_get_property_value(dev, "SEQNUM", &seqnum);
408 if (r < 0)
409 log_device_debug_errno(dev, r, "Failed to get SEQNUM: %m");
410
411 log_device_debug(dev, "Processing device (SEQNUM=%s)", seqnum);
412
413 udev_event = udev_event_new(dev, arg_exec_delay_usec, manager->rtnl);
414 if (!udev_event)
415 return -ENOMEM;
416
417 r = worker_lock_block_device(dev, &fd_lock);
418 if (r < 0)
419 return r;
420
421 /* apply rules, create node, symlinks */
422 udev_event_execute_rules(udev_event, arg_event_timeout_usec, manager->properties, manager->rules);
423 udev_event_execute_run(udev_event, arg_event_timeout_usec);
424
425 if (!manager->rtnl)
426 /* in case rtnl was initialized */
427 manager->rtnl = sd_netlink_ref(udev_event->rtnl);
428
429 /* apply/restore inotify watch */
430 if (udev_event->inotify_watch) {
431 (void) udev_watch_begin(dev);
432 r = device_update_db(dev);
433 if (r < 0)
434 return log_device_debug_errno(dev, r, "Failed to update database under /run/udev/data/: %m");
435 }
436
437 log_device_debug(dev, "Device (SEQNUM=%s) processed", seqnum);
438
439 return 0;
440 }
441
442 static int worker_main(Manager *_manager, struct udev_monitor *monitor, struct udev_device *first_device) {
443 _cleanup_(udev_device_unrefp) struct udev_device *dev = first_device;
444 _cleanup_(manager_freep) Manager *manager = _manager;
445 _cleanup_close_ int fd_signal = -1, fd_ep = -1;
446 struct epoll_event ep_signal = { .events = EPOLLIN };
447 struct epoll_event ep_monitor = { .events = EPOLLIN };
448 int fd_monitor, r;
449 sigset_t mask;
450
451 assert(manager);
452 assert(monitor);
453 assert(dev);
454
455 unsetenv("NOTIFY_SOCKET");
456
457 /* Clear unnecessary data form worker in Manager object.*/
458 manager_clear_for_worker(manager);
459
460 sigfillset(&mask);
461 fd_signal = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
462 if (fd_signal < 0)
463 return log_error_errno(errno, "error creating signalfd %m");
464 ep_signal.data.fd = fd_signal;
465
466 fd_monitor = udev_monitor_get_fd(monitor);
467 ep_monitor.data.fd = fd_monitor;
468
469 fd_ep = epoll_create1(EPOLL_CLOEXEC);
470 if (fd_ep < 0)
471 return log_error_errno(errno, "error creating epoll fd: %m");
472
473 if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_signal, &ep_signal) < 0 ||
474 epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_monitor, &ep_monitor) < 0)
475 return log_error_errno(errno, "fail to add fds to epoll: %m");
476
477 /* Request TERM signal if parent exits.
478 * Ignore error, not much we can do in that case. */
479 (void) prctl(PR_SET_PDEATHSIG, SIGTERM);
480
481 /* Reset OOM score, we only protect the main daemon. */
482 r = set_oom_score_adjust(0);
483 if (r < 0)
484 log_debug_errno(r, "Failed to reset OOM score, ignoring: %m");
485
486 for (;;) {
487 r = worker_process_device(manager, dev->device);
488 if (r < 0)
489 log_device_warning_errno(dev->device, r, "Failed to process device, ignoring: %m");
490
491 /* send processed event back to libudev listeners */
492 r = udev_monitor_send_device(monitor, NULL, dev);
493 if (r < 0)
494 log_device_warning_errno(dev->device, r, "Failed to send device to udev event listeners, ignoring: %m");
495
496 /* send udevd the result of the event execution */
497 r = worker_send_message(manager->worker_watch[WRITE_END]);
498 if (r < 0)
499 log_device_warning_errno(dev->device, r, "Failed to send result of seq %llu to main daemon: %m",
500 udev_device_get_seqnum(dev));
501
502 dev = udev_device_unref(dev);
503
504 /* wait for more device messages from main udevd, or term signal */
505 while (!dev) {
506 struct epoll_event ev[4];
507 int fdcount;
508 int i;
509
510 fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1);
511 if (fdcount < 0) {
512 if (errno == EINTR)
513 continue;
514 return log_error_errno(errno, "failed to poll: %m");
515 }
516
517 for (i = 0; i < fdcount; i++) {
518 if (ev[i].data.fd == fd_monitor && ev[i].events & EPOLLIN) {
519 dev = udev_monitor_receive_device(monitor);
520 break;
521 } else if (ev[i].data.fd == fd_signal && ev[i].events & EPOLLIN) {
522 struct signalfd_siginfo fdsi;
523 ssize_t size;
524
525 size = read(fd_signal, &fdsi, sizeof(struct signalfd_siginfo));
526 if (size != sizeof(struct signalfd_siginfo))
527 continue;
528 switch (fdsi.ssi_signo) {
529 case SIGTERM:
530 return 0;
531 }
532 }
533 }
534 }
535 }
536 }
537
538 static void worker_spawn(Manager *manager, struct event *event) {
539 _cleanup_(udev_monitor_unrefp) struct udev_monitor *worker_monitor = NULL;
540 pid_t pid;
541 int r = 0;
542
543 /* listen for new events */
544 worker_monitor = udev_monitor_new_from_netlink(NULL, NULL);
545 if (worker_monitor == NULL)
546 return;
547 /* allow the main daemon netlink address to send devices to the worker */
548 udev_monitor_allow_unicast_sender(worker_monitor, manager->monitor);
549 r = udev_monitor_enable_receiving(worker_monitor);
550 if (r < 0)
551 log_error_errno(r, "worker: could not enable receiving of device: %m");
552
553 pid = fork();
554 switch (pid) {
555 case 0: {
556 r = worker_main(manager, worker_monitor, TAKE_PTR(event->dev));
557 log_close();
558 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
559 }
560 case -1:
561 event->state = EVENT_QUEUED;
562 log_error_errno(errno, "fork of child failed: %m");
563 break;
564 default:
565 {
566 struct worker *worker;
567
568 r = worker_new(&worker, manager, worker_monitor, pid);
569 if (r < 0)
570 return;
571
572 worker_attach_event(worker, event);
573
574 log_debug("seq %llu forked new worker ["PID_FMT"]", udev_device_get_seqnum(event->dev), pid);
575 break;
576 }
577 }
578 }
579
580 static void event_run(Manager *manager, struct event *event) {
581 struct worker *worker;
582 Iterator i;
583
584 assert(manager);
585 assert(event);
586
587 HASHMAP_FOREACH(worker, manager->workers, i) {
588 ssize_t count;
589
590 if (worker->state != WORKER_IDLE)
591 continue;
592
593 count = udev_monitor_send_device(manager->monitor, worker->monitor, event->dev);
594 if (count < 0) {
595 log_error_errno(errno, "worker ["PID_FMT"] did not accept message %zi (%m), kill it",
596 worker->pid, count);
597 (void) kill(worker->pid, SIGKILL);
598 worker->state = WORKER_KILLED;
599 continue;
600 }
601 worker_attach_event(worker, event);
602 return;
603 }
604
605 if (hashmap_size(manager->workers) >= arg_children_max) {
606 if (arg_children_max > 1)
607 log_debug("maximum number (%i) of children reached", hashmap_size(manager->workers));
608 return;
609 }
610
611 /* start new worker and pass initial device */
612 worker_spawn(manager, event);
613 }
614
615 static int event_queue_insert(Manager *manager, struct udev_device *dev) {
616 struct event *event;
617 int r;
618
619 assert(manager);
620 assert(dev);
621
622 /* only one process can add events to the queue */
623 if (manager->pid == 0)
624 manager->pid = getpid_cached();
625
626 assert(manager->pid == getpid_cached());
627
628 event = new0(struct event, 1);
629 if (!event)
630 return -ENOMEM;
631
632 event->manager = manager;
633 event->dev = dev;
634 event->dev_kernel = udev_device_shallow_clone(dev);
635 udev_device_copy_properties(event->dev_kernel, dev);
636 event->seqnum = udev_device_get_seqnum(dev);
637 event->devpath = udev_device_get_devpath(dev);
638 event->devpath_len = strlen(event->devpath);
639 event->devpath_old = udev_device_get_devpath_old(dev);
640 event->devnum = udev_device_get_devnum(dev);
641 event->is_block = streq("block", udev_device_get_subsystem(dev));
642 event->ifindex = udev_device_get_ifindex(dev);
643
644 log_debug("seq %llu queued, '%s' '%s'", udev_device_get_seqnum(dev),
645 udev_device_get_action(dev), udev_device_get_subsystem(dev));
646
647 event->state = EVENT_QUEUED;
648
649 if (LIST_IS_EMPTY(manager->events)) {
650 r = touch("/run/udev/queue");
651 if (r < 0)
652 log_warning_errno(r, "could not touch /run/udev/queue: %m");
653 }
654
655 LIST_APPEND(event, manager->events, event);
656
657 return 0;
658 }
659
660 static void manager_kill_workers(Manager *manager) {
661 struct worker *worker;
662 Iterator i;
663
664 assert(manager);
665
666 HASHMAP_FOREACH(worker, manager->workers, i) {
667 if (worker->state == WORKER_KILLED)
668 continue;
669
670 worker->state = WORKER_KILLED;
671 (void) kill(worker->pid, SIGTERM);
672 }
673 }
674
675 /* lookup event for identical, parent, child device */
676 static bool is_devpath_busy(Manager *manager, struct event *event) {
677 struct event *loop_event;
678 size_t common;
679
680 /* check if queue contains events we depend on */
681 LIST_FOREACH(event, loop_event, manager->events) {
682 /* we already found a later event, earlier cannot block us, no need to check again */
683 if (loop_event->seqnum < event->delaying_seqnum)
684 continue;
685
686 /* event we checked earlier still exists, no need to check again */
687 if (loop_event->seqnum == event->delaying_seqnum)
688 return true;
689
690 /* found ourself, no later event can block us */
691 if (loop_event->seqnum >= event->seqnum)
692 break;
693
694 /* check major/minor */
695 if (major(event->devnum) != 0 && event->devnum == loop_event->devnum && event->is_block == loop_event->is_block)
696 return true;
697
698 /* check network device ifindex */
699 if (event->ifindex > 0 && event->ifindex == loop_event->ifindex)
700 return true;
701
702 /* check our old name */
703 if (event->devpath_old && streq(loop_event->devpath, event->devpath_old)) {
704 event->delaying_seqnum = loop_event->seqnum;
705 return true;
706 }
707
708 /* compare devpath */
709 common = MIN(loop_event->devpath_len, event->devpath_len);
710
711 /* one devpath is contained in the other? */
712 if (memcmp(loop_event->devpath, event->devpath, common) != 0)
713 continue;
714
715 /* identical device event found */
716 if (loop_event->devpath_len == event->devpath_len) {
717 /* devices names might have changed/swapped in the meantime */
718 if (major(event->devnum) != 0 || event->ifindex > 0)
719 continue;
720 event->delaying_seqnum = loop_event->seqnum;
721 return true;
722 }
723
724 /* parent device event found */
725 if (event->devpath[common] == '/') {
726 event->delaying_seqnum = loop_event->seqnum;
727 return true;
728 }
729
730 /* child device event found */
731 if (loop_event->devpath[common] == '/') {
732 event->delaying_seqnum = loop_event->seqnum;
733 return true;
734 }
735 }
736
737 return false;
738 }
739
740 static int on_exit_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
741 Manager *manager = userdata;
742
743 assert(manager);
744
745 log_error_errno(ETIMEDOUT, "giving up waiting for workers to finish");
746
747 sd_event_exit(manager->event, -ETIMEDOUT);
748
749 return 1;
750 }
751
752 static void manager_exit(Manager *manager) {
753 uint64_t usec;
754 int r;
755
756 assert(manager);
757
758 manager->exit = true;
759
760 sd_notify(false,
761 "STOPPING=1\n"
762 "STATUS=Starting shutdown...");
763
764 /* close sources of new events and discard buffered events */
765 manager->ctrl_event = sd_event_source_unref(manager->ctrl_event);
766 manager->ctrl = udev_ctrl_unref(manager->ctrl);
767
768 manager->inotify_event = sd_event_source_unref(manager->inotify_event);
769 manager->fd_inotify = safe_close(manager->fd_inotify);
770
771 manager->uevent_event = sd_event_source_unref(manager->uevent_event);
772 manager->monitor = udev_monitor_unref(manager->monitor);
773
774 /* discard queued events and kill workers */
775 event_queue_cleanup(manager, EVENT_QUEUED);
776 manager_kill_workers(manager);
777
778 assert_se(sd_event_now(manager->event, CLOCK_MONOTONIC, &usec) >= 0);
779
780 r = sd_event_add_time(manager->event, NULL, CLOCK_MONOTONIC,
781 usec + 30 * USEC_PER_SEC, USEC_PER_SEC, on_exit_timeout, manager);
782 if (r < 0)
783 return;
784 }
785
786 /* reload requested, HUP signal received, rules changed, builtin changed */
787 static void manager_reload(Manager *manager) {
788
789 assert(manager);
790
791 sd_notify(false,
792 "RELOADING=1\n"
793 "STATUS=Flushing configuration...");
794
795 manager_kill_workers(manager);
796 manager->rules = udev_rules_unref(manager->rules);
797 udev_builtin_exit();
798
799 sd_notifyf(false,
800 "READY=1\n"
801 "STATUS=Processing with %u children at max", arg_children_max);
802 }
803
804 static int on_kill_workers_event(sd_event_source *s, uint64_t usec, void *userdata) {
805 Manager *manager = userdata;
806
807 assert(manager);
808
809 log_debug("Cleanup idle workers");
810 manager_kill_workers(manager);
811
812 return 1;
813 }
814
815 static void event_queue_start(Manager *manager) {
816 struct event *event;
817 usec_t usec;
818 int r;
819
820 assert(manager);
821
822 if (LIST_IS_EMPTY(manager->events) ||
823 manager->exit || manager->stop_exec_queue)
824 return;
825
826 assert_se(sd_event_now(manager->event, CLOCK_MONOTONIC, &usec) >= 0);
827 /* check for changed config, every 3 seconds at most */
828 if (manager->last_usec == 0 ||
829 (usec - manager->last_usec) > 3 * USEC_PER_SEC) {
830 if (udev_rules_check_timestamp(manager->rules) ||
831 udev_builtin_validate())
832 manager_reload(manager);
833
834 manager->last_usec = usec;
835 }
836
837 r = event_source_disable(manager->kill_workers_event);
838 if (r < 0)
839 log_warning_errno(r, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
840
841 udev_builtin_init();
842
843 if (!manager->rules) {
844 manager->rules = udev_rules_new(arg_resolve_name_timing);
845 if (!manager->rules)
846 return;
847 }
848
849 LIST_FOREACH(event,event,manager->events) {
850 if (event->state != EVENT_QUEUED)
851 continue;
852
853 /* do not start event if parent or child event is still running */
854 if (is_devpath_busy(manager, event))
855 continue;
856
857 event_run(manager, event);
858 }
859 }
860
861 static void event_queue_cleanup(Manager *manager, enum event_state match_type) {
862 struct event *event, *tmp;
863
864 LIST_FOREACH_SAFE(event, event, tmp, manager->events) {
865 if (match_type != EVENT_UNDEF && match_type != event->state)
866 continue;
867
868 event_free(event);
869 }
870 }
871
872 static int on_worker(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
873 Manager *manager = userdata;
874
875 assert(manager);
876
877 for (;;) {
878 struct worker_message msg;
879 struct iovec iovec = {
880 .iov_base = &msg,
881 .iov_len = sizeof(msg),
882 };
883 union {
884 struct cmsghdr cmsghdr;
885 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
886 } control = {};
887 struct msghdr msghdr = {
888 .msg_iov = &iovec,
889 .msg_iovlen = 1,
890 .msg_control = &control,
891 .msg_controllen = sizeof(control),
892 };
893 struct cmsghdr *cmsg;
894 ssize_t size;
895 struct ucred *ucred = NULL;
896 struct worker *worker;
897
898 size = recvmsg(fd, &msghdr, MSG_DONTWAIT);
899 if (size < 0) {
900 if (errno == EINTR)
901 continue;
902 else if (errno == EAGAIN)
903 /* nothing more to read */
904 break;
905
906 return log_error_errno(errno, "failed to receive message: %m");
907 } else if (size != sizeof(struct worker_message)) {
908 log_warning_errno(EIO, "ignoring worker message with invalid size %zi bytes", size);
909 continue;
910 }
911
912 CMSG_FOREACH(cmsg, &msghdr) {
913 if (cmsg->cmsg_level == SOL_SOCKET &&
914 cmsg->cmsg_type == SCM_CREDENTIALS &&
915 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
916 ucred = (struct ucred*) CMSG_DATA(cmsg);
917 }
918
919 if (!ucred || ucred->pid <= 0) {
920 log_warning_errno(EIO, "ignoring worker message without valid PID");
921 continue;
922 }
923
924 /* lookup worker who sent the signal */
925 worker = hashmap_get(manager->workers, PID_TO_PTR(ucred->pid));
926 if (!worker) {
927 log_debug("worker ["PID_FMT"] returned, but is no longer tracked", ucred->pid);
928 continue;
929 }
930
931 if (worker->state != WORKER_KILLED)
932 worker->state = WORKER_IDLE;
933
934 /* worker returned */
935 event_free(worker->event);
936 }
937
938 /* we have free workers, try to schedule events */
939 event_queue_start(manager);
940
941 return 1;
942 }
943
944 static int on_uevent(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
945 Manager *manager = userdata;
946 struct udev_device *dev;
947 int r;
948
949 assert(manager);
950
951 dev = udev_monitor_receive_device(manager->monitor);
952 if (dev) {
953 udev_device_ensure_usec_initialized(dev, NULL);
954 r = event_queue_insert(manager, dev);
955 if (r < 0)
956 udev_device_unref(dev);
957 else
958 /* we have fresh events, try to schedule them */
959 event_queue_start(manager);
960 }
961
962 return 1;
963 }
964
965 /* receive the udevd message from userspace */
966 static int on_ctrl_msg(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
967 Manager *manager = userdata;
968 _cleanup_(udev_ctrl_connection_unrefp) struct udev_ctrl_connection *ctrl_conn = NULL;
969 _cleanup_(udev_ctrl_msg_unrefp) struct udev_ctrl_msg *ctrl_msg = NULL;
970 const char *str;
971 int i, r;
972
973 assert(manager);
974
975 ctrl_conn = udev_ctrl_get_connection(manager->ctrl);
976 if (!ctrl_conn)
977 return 1;
978
979 ctrl_msg = udev_ctrl_receive_msg(ctrl_conn);
980 if (!ctrl_msg)
981 return 1;
982
983 i = udev_ctrl_get_set_log_level(ctrl_msg);
984 if (i >= 0) {
985 log_debug("udevd message (SET_LOG_LEVEL) received, log_priority=%i", i);
986 log_set_max_level(i);
987 manager_kill_workers(manager);
988 }
989
990 if (udev_ctrl_get_stop_exec_queue(ctrl_msg) > 0) {
991 log_debug("udevd message (STOP_EXEC_QUEUE) received");
992 manager->stop_exec_queue = true;
993 }
994
995 if (udev_ctrl_get_start_exec_queue(ctrl_msg) > 0) {
996 log_debug("udevd message (START_EXEC_QUEUE) received");
997 manager->stop_exec_queue = false;
998 event_queue_start(manager);
999 }
1000
1001 if (udev_ctrl_get_reload(ctrl_msg) > 0) {
1002 log_debug("udevd message (RELOAD) received");
1003 manager_reload(manager);
1004 }
1005
1006 str = udev_ctrl_get_set_env(ctrl_msg);
1007 if (str) {
1008 _cleanup_free_ char *key = NULL, *val = NULL, *old_key = NULL, *old_val = NULL;
1009 char *eq;
1010
1011 eq = strchr(str, '=');
1012 if (!eq) {
1013 log_error("Invalid key format '%s'", str);
1014 return 1;
1015 }
1016
1017 key = strndup(str, eq - str);
1018 if (!key) {
1019 log_oom();
1020 return 1;
1021 }
1022
1023 old_val = hashmap_remove2(manager->properties, key, (void **) &old_key);
1024
1025 r = hashmap_ensure_allocated(&manager->properties, &string_hash_ops);
1026 if (r < 0) {
1027 log_oom();
1028 return 1;
1029 }
1030
1031 eq++;
1032 if (!isempty(eq)) {
1033 log_debug("udevd message (ENV) received, unset '%s'", key);
1034
1035 r = hashmap_put(manager->properties, key, NULL);
1036 if (r < 0) {
1037 log_oom();
1038 return 1;
1039 }
1040 } else {
1041 val = strdup(eq);
1042 if (!val) {
1043 log_oom();
1044 return 1;
1045 }
1046
1047 log_debug("udevd message (ENV) received, set '%s=%s'", key, val);
1048
1049 r = hashmap_put(manager->properties, key, val);
1050 if (r < 0) {
1051 log_oom();
1052 return 1;
1053 }
1054 }
1055
1056 key = val = NULL;
1057 manager_kill_workers(manager);
1058 }
1059
1060 i = udev_ctrl_get_set_children_max(ctrl_msg);
1061 if (i >= 0) {
1062 log_debug("udevd message (SET_MAX_CHILDREN) received, children_max=%i", i);
1063 arg_children_max = i;
1064
1065 (void) sd_notifyf(false,
1066 "READY=1\n"
1067 "STATUS=Processing with %u children at max", arg_children_max);
1068 }
1069
1070 if (udev_ctrl_get_ping(ctrl_msg) > 0)
1071 log_debug("udevd message (SYNC) received");
1072
1073 if (udev_ctrl_get_exit(ctrl_msg) > 0) {
1074 log_debug("udevd message (EXIT) received");
1075 manager_exit(manager);
1076 /* keep reference to block the client until we exit
1077 TODO: deal with several blocking exit requests */
1078 manager->ctrl_conn_blocking = udev_ctrl_connection_ref(ctrl_conn);
1079 }
1080
1081 return 1;
1082 }
1083
1084 static int synthesize_change(sd_device *dev) {
1085 const char *subsystem, *sysname, *devname, *syspath, *devtype;
1086 char filename[PATH_MAX];
1087 int r;
1088
1089 r = sd_device_get_subsystem(dev, &subsystem);
1090 if (r < 0)
1091 return r;
1092
1093 r = sd_device_get_sysname(dev, &sysname);
1094 if (r < 0)
1095 return r;
1096
1097 r = sd_device_get_devname(dev, &devname);
1098 if (r < 0)
1099 return r;
1100
1101 r = sd_device_get_syspath(dev, &syspath);
1102 if (r < 0)
1103 return r;
1104
1105 r = sd_device_get_devtype(dev, &devtype);
1106 if (r < 0)
1107 return r;
1108
1109 if (streq_ptr("block", subsystem) &&
1110 streq_ptr("disk", devtype) &&
1111 !startswith(sysname, "dm-")) {
1112 _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
1113 bool part_table_read = false, has_partitions = false;
1114 sd_device *d;
1115 int fd;
1116
1117 /*
1118 * Try to re-read the partition table. This only succeeds if
1119 * none of the devices is busy. The kernel returns 0 if no
1120 * partition table is found, and we will not get an event for
1121 * the disk.
1122 */
1123 fd = open(devname, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK);
1124 if (fd >= 0) {
1125 r = flock(fd, LOCK_EX|LOCK_NB);
1126 if (r >= 0)
1127 r = ioctl(fd, BLKRRPART, 0);
1128
1129 close(fd);
1130 if (r >= 0)
1131 part_table_read = true;
1132 }
1133
1134 /* search for partitions */
1135 r = sd_device_enumerator_new(&e);
1136 if (r < 0)
1137 return r;
1138
1139 r = sd_device_enumerator_allow_uninitialized(e);
1140 if (r < 0)
1141 return r;
1142
1143 r = sd_device_enumerator_add_match_parent(e, dev);
1144 if (r < 0)
1145 return r;
1146
1147 r = sd_device_enumerator_add_match_subsystem(e, "block", true);
1148 if (r < 0)
1149 return r;
1150
1151 FOREACH_DEVICE(e, d) {
1152 const char *t;
1153
1154 if (sd_device_get_devtype(d, &t) < 0 ||
1155 !streq("partition", t))
1156 continue;
1157
1158 has_partitions = true;
1159 break;
1160 }
1161
1162 /*
1163 * We have partitions and re-read the table, the kernel already sent
1164 * out a "change" event for the disk, and "remove/add" for all
1165 * partitions.
1166 */
1167 if (part_table_read && has_partitions)
1168 return 0;
1169
1170 /*
1171 * We have partitions but re-reading the partition table did not
1172 * work, synthesize "change" for the disk and all partitions.
1173 */
1174 log_debug("Device '%s' is closed, synthesising 'change'", devname);
1175 strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
1176 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1177
1178 FOREACH_DEVICE(e, d) {
1179 const char *t, *n, *s;
1180
1181 if (sd_device_get_devtype(d, &t) < 0 ||
1182 !streq("partition", t))
1183 continue;
1184
1185 if (sd_device_get_devname(d, &n) < 0 ||
1186 sd_device_get_syspath(d, &s) < 0)
1187 continue;
1188
1189 log_debug("Device '%s' is closed, synthesising partition '%s' 'change'", devname, n);
1190 strscpyl(filename, sizeof(filename), s, "/uevent", NULL);
1191 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1192 }
1193
1194 return 0;
1195 }
1196
1197 log_debug("Device %s is closed, synthesising 'change'", devname);
1198 strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
1199 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1200
1201 return 0;
1202 }
1203
1204 static int on_inotify(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1205 Manager *manager = userdata;
1206 union inotify_event_buffer buffer;
1207 struct inotify_event *e;
1208 ssize_t l;
1209 int r;
1210
1211 assert(manager);
1212
1213 r = event_source_disable(manager->kill_workers_event);
1214 if (r < 0)
1215 log_warning_errno(r, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
1216
1217 l = read(fd, &buffer, sizeof(buffer));
1218 if (l < 0) {
1219 if (IN_SET(errno, EAGAIN, EINTR))
1220 return 1;
1221
1222 return log_error_errno(errno, "Failed to read inotify fd: %m");
1223 }
1224
1225 FOREACH_INOTIFY_EVENT(e, buffer, l) {
1226 _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
1227 const char *devnode;
1228
1229 if (udev_watch_lookup(e->wd, &dev) <= 0)
1230 continue;
1231
1232 if (sd_device_get_devname(dev, &devnode) < 0)
1233 continue;
1234
1235 log_device_debug(dev, "Inotify event: %x for %s", e->mask, devnode);
1236 if (e->mask & IN_CLOSE_WRITE)
1237 synthesize_change(dev);
1238 else if (e->mask & IN_IGNORED)
1239 udev_watch_end(dev);
1240 }
1241
1242 return 1;
1243 }
1244
1245 static int on_sigterm(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1246 Manager *manager = userdata;
1247
1248 assert(manager);
1249
1250 manager_exit(manager);
1251
1252 return 1;
1253 }
1254
1255 static int on_sighup(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1256 Manager *manager = userdata;
1257
1258 assert(manager);
1259
1260 manager_reload(manager);
1261
1262 return 1;
1263 }
1264
1265 static int on_sigchld(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1266 Manager *manager = userdata;
1267 int r;
1268
1269 assert(manager);
1270
1271 for (;;) {
1272 pid_t pid;
1273 int status;
1274 struct worker *worker;
1275
1276 pid = waitpid(-1, &status, WNOHANG);
1277 if (pid <= 0)
1278 break;
1279
1280 worker = hashmap_get(manager->workers, PID_TO_PTR(pid));
1281 if (!worker) {
1282 log_warning("worker ["PID_FMT"] is unknown, ignoring", pid);
1283 continue;
1284 }
1285
1286 if (WIFEXITED(status)) {
1287 if (WEXITSTATUS(status) == 0)
1288 log_debug("worker ["PID_FMT"] exited", pid);
1289 else
1290 log_warning("worker ["PID_FMT"] exited with return code %i", pid, WEXITSTATUS(status));
1291 } else if (WIFSIGNALED(status)) {
1292 log_warning("worker ["PID_FMT"] terminated by signal %i (%s)", pid, WTERMSIG(status), signal_to_string(WTERMSIG(status)));
1293 } else if (WIFSTOPPED(status)) {
1294 log_info("worker ["PID_FMT"] stopped", pid);
1295 continue;
1296 } else if (WIFCONTINUED(status)) {
1297 log_info("worker ["PID_FMT"] continued", pid);
1298 continue;
1299 } else
1300 log_warning("worker ["PID_FMT"] exit with status 0x%04x", pid, status);
1301
1302 if ((!WIFEXITED(status) || WEXITSTATUS(status) != 0) && worker->event) {
1303 log_error("worker ["PID_FMT"] failed while handling '%s'", pid, worker->event->devpath);
1304 /* delete state from disk */
1305 udev_device_delete_db(worker->event->dev);
1306 udev_device_tag_index(worker->event->dev, NULL, false);
1307 /* forward kernel event without amending it */
1308 udev_monitor_send_device(manager->monitor, NULL, worker->event->dev_kernel);
1309 }
1310
1311 worker_free(worker);
1312 }
1313
1314 /* we can start new workers, try to schedule events */
1315 event_queue_start(manager);
1316
1317 /* Disable unnecessary cleanup event */
1318 if (hashmap_isempty(manager->workers)) {
1319 r = event_source_disable(manager->kill_workers_event);
1320 if (r < 0)
1321 log_warning_errno(r, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
1322 }
1323
1324 return 1;
1325 }
1326
1327 static int on_post(sd_event_source *s, void *userdata) {
1328 Manager *manager = userdata;
1329
1330 assert(manager);
1331
1332 if (!LIST_IS_EMPTY(manager->events))
1333 return 1;
1334
1335 /* There are no pending events. Let's cleanup idle process. */
1336
1337 if (!hashmap_isempty(manager->workers)) {
1338 /* There are idle workers */
1339 (void) event_reset_time(manager->event, &manager->kill_workers_event, CLOCK_MONOTONIC,
1340 now(CLOCK_MONOTONIC) + 3 * USEC_PER_SEC, USEC_PER_SEC,
1341 on_kill_workers_event, manager, 0, "kill-workers-event", false);
1342 return 1;
1343 }
1344
1345 /* There are no idle workers. */
1346
1347 if (manager->exit)
1348 return sd_event_exit(manager->event, 0);
1349
1350 if (manager->cgroup)
1351 /* cleanup possible left-over processes in our cgroup */
1352 (void) cg_kill(SYSTEMD_CGROUP_CONTROLLER, manager->cgroup, SIGKILL, CGROUP_IGNORE_SELF, NULL, NULL, NULL);
1353
1354 return 1;
1355 }
1356
1357 static int listen_fds(int *ret_ctrl, int *ret_netlink) {
1358 int ctrl_fd = -1, netlink_fd = -1;
1359 int fd, n;
1360
1361 assert(ret_ctrl);
1362 assert(ret_netlink);
1363
1364 n = sd_listen_fds(true);
1365 if (n < 0)
1366 return n;
1367
1368 for (fd = SD_LISTEN_FDS_START; fd < n + SD_LISTEN_FDS_START; fd++) {
1369 if (sd_is_socket(fd, AF_LOCAL, SOCK_SEQPACKET, -1) > 0) {
1370 if (ctrl_fd >= 0)
1371 return -EINVAL;
1372 ctrl_fd = fd;
1373 continue;
1374 }
1375
1376 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
1377 if (netlink_fd >= 0)
1378 return -EINVAL;
1379 netlink_fd = fd;
1380 continue;
1381 }
1382
1383 return -EINVAL;
1384 }
1385
1386 *ret_ctrl = ctrl_fd;
1387 *ret_netlink = netlink_fd;
1388
1389 return 0;
1390 }
1391
1392 /*
1393 * read the kernel command line, in case we need to get into debug mode
1394 * udev.log_priority=<level> syslog priority
1395 * udev.children_max=<number of workers> events are fully serialized if set to 1
1396 * udev.exec_delay=<number of seconds> delay execution of every executed program
1397 * udev.event_timeout=<number of seconds> seconds to wait before terminating an event
1398 */
1399 static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
1400 int r = 0;
1401
1402 assert(key);
1403
1404 if (!value)
1405 return 0;
1406
1407 if (proc_cmdline_key_streq(key, "udev.log_priority")) {
1408
1409 if (proc_cmdline_value_missing(key, value))
1410 return 0;
1411
1412 r = log_level_from_string(value);
1413 if (r >= 0)
1414 log_set_max_level(r);
1415
1416 } else if (proc_cmdline_key_streq(key, "udev.event_timeout")) {
1417
1418 if (proc_cmdline_value_missing(key, value))
1419 return 0;
1420
1421 r = parse_sec(value, &arg_event_timeout_usec);
1422
1423 } else if (proc_cmdline_key_streq(key, "udev.children_max")) {
1424
1425 if (proc_cmdline_value_missing(key, value))
1426 return 0;
1427
1428 r = safe_atou(value, &arg_children_max);
1429
1430 } else if (proc_cmdline_key_streq(key, "udev.exec_delay")) {
1431
1432 if (proc_cmdline_value_missing(key, value))
1433 return 0;
1434
1435 r = parse_sec(value, &arg_exec_delay_usec);
1436
1437 } else if (startswith(key, "udev."))
1438 log_warning("Unknown udev kernel command line option \"%s\"", key);
1439
1440 if (r < 0)
1441 log_warning_errno(r, "Failed to parse \"%s=%s\", ignoring: %m", key, value);
1442
1443 return 0;
1444 }
1445
1446 static int help(void) {
1447 _cleanup_free_ char *link = NULL;
1448 int r;
1449
1450 r = terminal_urlify_man("systemd-udevd.service", "8", &link);
1451 if (r < 0)
1452 return log_oom();
1453
1454 printf("%s [OPTIONS...]\n\n"
1455 "Manages devices.\n\n"
1456 " -h --help Print this message\n"
1457 " -V --version Print version of the program\n"
1458 " -d --daemon Detach and run in the background\n"
1459 " -D --debug Enable debug output\n"
1460 " -c --children-max=INT Set maximum number of workers\n"
1461 " -e --exec-delay=SECONDS Seconds to wait before executing RUN=\n"
1462 " -t --event-timeout=SECONDS Seconds to wait before terminating an event\n"
1463 " -N --resolve-names=early|late|never\n"
1464 " When to resolve users and groups\n"
1465 "\nSee the %s for details.\n"
1466 , program_invocation_short_name
1467 , link
1468 );
1469
1470 return 0;
1471 }
1472
1473 static int parse_argv(int argc, char *argv[]) {
1474 static const struct option options[] = {
1475 { "daemon", no_argument, NULL, 'd' },
1476 { "debug", no_argument, NULL, 'D' },
1477 { "children-max", required_argument, NULL, 'c' },
1478 { "exec-delay", required_argument, NULL, 'e' },
1479 { "event-timeout", required_argument, NULL, 't' },
1480 { "resolve-names", required_argument, NULL, 'N' },
1481 { "help", no_argument, NULL, 'h' },
1482 { "version", no_argument, NULL, 'V' },
1483 {}
1484 };
1485
1486 int c;
1487
1488 assert(argc >= 0);
1489 assert(argv);
1490
1491 while ((c = getopt_long(argc, argv, "c:de:Dt:N:hV", options, NULL)) >= 0) {
1492 int r;
1493
1494 switch (c) {
1495
1496 case 'd':
1497 arg_daemonize = true;
1498 break;
1499 case 'c':
1500 r = safe_atou(optarg, &arg_children_max);
1501 if (r < 0)
1502 log_warning_errno(r, "Failed to parse --children-max= value '%s', ignoring: %m", optarg);
1503 break;
1504 case 'e':
1505 r = parse_sec(optarg, &arg_exec_delay_usec);
1506 if (r < 0)
1507 log_warning_errno(r, "Failed to parse --exec-delay= value '%s', ignoring: %m", optarg);
1508 break;
1509 case 't':
1510 r = parse_sec(optarg, &arg_event_timeout_usec);
1511 if (r < 0)
1512 log_warning_errno(r, "Failed to parse --event-timeout= value '%s', ignoring: %m", optarg);
1513 break;
1514 case 'D':
1515 arg_debug = true;
1516 break;
1517 case 'N': {
1518 ResolveNameTiming t;
1519
1520 t = resolve_name_timing_from_string(optarg);
1521 if (t < 0)
1522 log_warning("Invalid --resolve-names= value '%s', ignoring.", optarg);
1523 else
1524 arg_resolve_name_timing = t;
1525 break;
1526 }
1527 case 'h':
1528 return help();
1529 case 'V':
1530 printf("%s\n", PACKAGE_VERSION);
1531 return 0;
1532 case '?':
1533 return -EINVAL;
1534 default:
1535 assert_not_reached("Unhandled option");
1536
1537 }
1538 }
1539
1540 return 1;
1541 }
1542
1543 static int manager_new(Manager **ret, int fd_ctrl, int fd_uevent, const char *cgroup) {
1544 _cleanup_(manager_freep) Manager *manager = NULL;
1545 int r, fd_worker;
1546
1547 assert(ret);
1548
1549 manager = new(Manager, 1);
1550 if (!manager)
1551 return log_oom();
1552
1553 *manager = (Manager) {
1554 .fd_inotify = -1,
1555 .worker_watch = { -1, -1 },
1556 .cgroup = cgroup,
1557 };
1558
1559 udev_builtin_init();
1560
1561 manager->rules = udev_rules_new(arg_resolve_name_timing);
1562 if (!manager->rules)
1563 return log_error_errno(ENOMEM, "error reading rules");
1564
1565 manager->ctrl = udev_ctrl_new_from_fd(fd_ctrl);
1566 if (!manager->ctrl)
1567 return log_error_errno(EINVAL, "error taking over udev control socket");
1568
1569 r = udev_ctrl_enable_receiving(manager->ctrl);
1570 if (r < 0)
1571 return log_error_errno(r, "Failed to bind udev control socket: %m");
1572
1573 fd_ctrl = udev_ctrl_get_fd(manager->ctrl);
1574 if (fd_ctrl < 0)
1575 return log_error_errno(fd_ctrl, "Failed to get udev control fd: %m");
1576
1577 manager->monitor = udev_monitor_new_from_netlink_fd(NULL, "kernel", fd_uevent);
1578 if (!manager->monitor)
1579 return log_error_errno(EINVAL, "error taking over netlink socket");
1580
1581 (void) udev_monitor_set_receive_buffer_size(manager->monitor, 128 * 1024 * 1024);
1582
1583 r = udev_monitor_enable_receiving(manager->monitor);
1584 if (r < 0)
1585 return log_error_errno(r, "Failed to bind netlink socket; %m");
1586
1587 fd_uevent = udev_monitor_get_fd(manager->monitor);
1588 if (fd_uevent < 0)
1589 return log_error_errno(fd_uevent, "Failed to get uevent fd: %m");
1590
1591 /* unnamed socket from workers to the main daemon */
1592 r = socketpair(AF_LOCAL, SOCK_DGRAM|SOCK_CLOEXEC, 0, manager->worker_watch);
1593 if (r < 0)
1594 return log_error_errno(errno, "error creating socketpair: %m");
1595
1596 fd_worker = manager->worker_watch[READ_END];
1597
1598 r = setsockopt_int(fd_worker, SOL_SOCKET, SO_PASSCRED, true);
1599 if (r < 0)
1600 return log_error_errno(r, "could not enable SO_PASSCRED: %m");
1601
1602 r = udev_watch_init();
1603 if (r < 0)
1604 return log_error_errno(r, "Failed to create inotify descriptor: %m");
1605 manager->fd_inotify = r;
1606
1607 udev_watch_restore();
1608
1609 /* block and listen to all signals on signalfd */
1610 assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, SIGHUP, SIGCHLD, -1) >= 0);
1611
1612 r = sd_event_default(&manager->event);
1613 if (r < 0)
1614 return log_error_errno(r, "could not allocate event loop: %m");
1615
1616 r = sd_event_add_signal(manager->event, NULL, SIGINT, on_sigterm, manager);
1617 if (r < 0)
1618 return log_error_errno(r, "error creating sigint event source: %m");
1619
1620 r = sd_event_add_signal(manager->event, NULL, SIGTERM, on_sigterm, manager);
1621 if (r < 0)
1622 return log_error_errno(r, "error creating sigterm event source: %m");
1623
1624 r = sd_event_add_signal(manager->event, NULL, SIGHUP, on_sighup, manager);
1625 if (r < 0)
1626 return log_error_errno(r, "error creating sighup event source: %m");
1627
1628 r = sd_event_add_signal(manager->event, NULL, SIGCHLD, on_sigchld, manager);
1629 if (r < 0)
1630 return log_error_errno(r, "error creating sigchld event source: %m");
1631
1632 r = sd_event_set_watchdog(manager->event, true);
1633 if (r < 0)
1634 return log_error_errno(r, "error creating watchdog event source: %m");
1635
1636 r = sd_event_add_io(manager->event, &manager->ctrl_event, fd_ctrl, EPOLLIN, on_ctrl_msg, manager);
1637 if (r < 0)
1638 return log_error_errno(r, "error creating ctrl event source: %m");
1639
1640 /* This needs to be after the inotify and uevent handling, to make sure
1641 * that the ping is send back after fully processing the pending uevents
1642 * (including the synthetic ones we may create due to inotify events).
1643 */
1644 r = sd_event_source_set_priority(manager->ctrl_event, SD_EVENT_PRIORITY_IDLE);
1645 if (r < 0)
1646 return log_error_errno(r, "cold not set IDLE event priority for ctrl event source: %m");
1647
1648 r = sd_event_add_io(manager->event, &manager->inotify_event, manager->fd_inotify, EPOLLIN, on_inotify, manager);
1649 if (r < 0)
1650 return log_error_errno(r, "error creating inotify event source: %m");
1651
1652 r = sd_event_add_io(manager->event, &manager->uevent_event, fd_uevent, EPOLLIN, on_uevent, manager);
1653 if (r < 0)
1654 return log_error_errno(r, "error creating uevent event source: %m");
1655
1656 r = sd_event_add_io(manager->event, NULL, fd_worker, EPOLLIN, on_worker, manager);
1657 if (r < 0)
1658 return log_error_errno(r, "error creating worker event source: %m");
1659
1660 r = sd_event_add_post(manager->event, NULL, on_post, manager);
1661 if (r < 0)
1662 return log_error_errno(r, "error creating post event source: %m");
1663
1664 *ret = TAKE_PTR(manager);
1665
1666 return 0;
1667 }
1668
1669 static int run(int fd_ctrl, int fd_uevent, const char *cgroup) {
1670 _cleanup_(manager_freep) Manager *manager = NULL;
1671 int r;
1672
1673 r = manager_new(&manager, fd_ctrl, fd_uevent, cgroup);
1674 if (r < 0) {
1675 r = log_error_errno(r, "failed to allocate manager object: %m");
1676 goto exit;
1677 }
1678
1679 r = udev_rules_apply_static_dev_perms(manager->rules);
1680 if (r < 0)
1681 log_error_errno(r, "failed to apply permissions on static device nodes: %m");
1682
1683 (void) sd_notifyf(false,
1684 "READY=1\n"
1685 "STATUS=Processing with %u children at max", arg_children_max);
1686
1687 r = sd_event_loop(manager->event);
1688 if (r < 0) {
1689 log_error_errno(r, "event loop failed: %m");
1690 goto exit;
1691 }
1692
1693 sd_event_get_exit_code(manager->event, &r);
1694
1695 exit:
1696 sd_notify(false,
1697 "STOPPING=1\n"
1698 "STATUS=Shutting down...");
1699 if (manager)
1700 udev_ctrl_cleanup(manager->ctrl);
1701 return r;
1702 }
1703
1704 int main(int argc, char *argv[]) {
1705 _cleanup_free_ char *cgroup = NULL;
1706 int fd_ctrl = -1, fd_uevent = -1;
1707 int r;
1708
1709 log_set_target(LOG_TARGET_AUTO);
1710 udev_parse_config_full(&arg_children_max, &arg_exec_delay_usec, &arg_event_timeout_usec, &arg_resolve_name_timing);
1711 log_parse_environment();
1712 log_open();
1713
1714 r = parse_argv(argc, argv);
1715 if (r <= 0)
1716 goto exit;
1717
1718 r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX);
1719 if (r < 0)
1720 log_warning_errno(r, "failed to parse kernel command line, ignoring: %m");
1721
1722 if (arg_debug) {
1723 log_set_target(LOG_TARGET_CONSOLE);
1724 log_set_max_level(LOG_DEBUG);
1725 }
1726
1727 log_set_max_level_realm(LOG_REALM_SYSTEMD, log_get_max_level());
1728
1729 r = must_be_root();
1730 if (r < 0)
1731 goto exit;
1732
1733 if (arg_children_max == 0) {
1734 cpu_set_t cpu_set;
1735 unsigned long mem_limit;
1736
1737 arg_children_max = 8;
1738
1739 if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set) == 0)
1740 arg_children_max += CPU_COUNT(&cpu_set) * 8;
1741
1742 mem_limit = physical_memory() / (128LU*1024*1024);
1743 arg_children_max = MAX(10U, MIN(arg_children_max, mem_limit));
1744
1745 log_debug("set children_max to %u", arg_children_max);
1746 }
1747
1748 /* set umask before creating any file/directory */
1749 r = chdir("/");
1750 if (r < 0) {
1751 r = log_error_errno(errno, "could not change dir to /: %m");
1752 goto exit;
1753 }
1754
1755 umask(022);
1756
1757 r = mac_selinux_init();
1758 if (r < 0) {
1759 log_error_errno(r, "could not initialize labelling: %m");
1760 goto exit;
1761 }
1762
1763 r = mkdir_errno_wrapper("/run/udev", 0755);
1764 if (r < 0 && r != -EEXIST) {
1765 log_error_errno(r, "could not create /run/udev: %m");
1766 goto exit;
1767 }
1768
1769 dev_setup(NULL, UID_INVALID, GID_INVALID);
1770
1771 if (getppid() == 1) {
1772 /* get our own cgroup, we regularly kill everything udev has left behind
1773 we only do this on systemd systems, and only if we are directly spawned
1774 by PID1. otherwise we are not guaranteed to have a dedicated cgroup */
1775 r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 0, &cgroup);
1776 if (r < 0) {
1777 if (IN_SET(r, -ENOENT, -ENOMEDIUM))
1778 log_debug_errno(r, "did not find dedicated cgroup: %m");
1779 else
1780 log_warning_errno(r, "failed to get cgroup: %m");
1781 }
1782 }
1783
1784 r = listen_fds(&fd_ctrl, &fd_uevent);
1785 if (r < 0) {
1786 r = log_error_errno(r, "could not listen on fds: %m");
1787 goto exit;
1788 }
1789
1790 if (arg_daemonize) {
1791 pid_t pid;
1792
1793 log_info("starting version " PACKAGE_VERSION);
1794
1795 /* connect /dev/null to stdin, stdout, stderr */
1796 if (log_get_max_level() < LOG_DEBUG) {
1797 r = make_null_stdio();
1798 if (r < 0)
1799 log_warning_errno(r, "Failed to redirect standard streams to /dev/null: %m");
1800 }
1801
1802 pid = fork();
1803 switch (pid) {
1804 case 0:
1805 break;
1806 case -1:
1807 r = log_error_errno(errno, "fork of daemon failed: %m");
1808 goto exit;
1809 default:
1810 mac_selinux_finish();
1811 log_close();
1812 _exit(EXIT_SUCCESS);
1813 }
1814
1815 setsid();
1816
1817 r = set_oom_score_adjust(-1000);
1818 if (r < 0)
1819 log_debug_errno(r, "Failed to adjust OOM score, ignoring: %m");
1820 }
1821
1822 r = run(fd_ctrl, fd_uevent, cgroup);
1823
1824 exit:
1825 mac_selinux_finish();
1826 log_close();
1827 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1828 }
Unnamed repository; edit this file 'description' to name the repository.