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