]> 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 #10610 from yuwata/udev-rules-cleanups
[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 "terminal-util.h"
55 #include "udev-builtin.h"
56 #include "udev-ctrl.h"
57 #include "udev-util.h"
58 #include "udev-watch.h"
59 #include "udev.h"
60 #include "user-util.h"
61
62 static bool arg_debug = false;
63 static int arg_daemonize = false;
64 static int arg_resolve_names = 1;
65 static unsigned arg_children_max;
66 static int arg_exec_delay;
67 static usec_t arg_event_timeout_usec = 180 * USEC_PER_SEC;
68 static usec_t arg_event_timeout_warn_usec = 180 * USEC_PER_SEC / 3;
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 + arg_event_timeout_warn_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, 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,
445 arg_event_timeout_usec, arg_event_timeout_warn_usec,
446 manager->properties,
447 manager->rules);
448
449 udev_event_execute_run(udev_event,
450 arg_event_timeout_usec, arg_event_timeout_warn_usec);
451
452 if (!rtnl)
453 /* in case rtnl was initialized */
454 rtnl = sd_netlink_ref(udev_event->rtnl);
455
456 /* apply/restore inotify watch */
457 if (udev_event->inotify_watch) {
458 udev_watch_begin(dev->device);
459 udev_device_update_db(dev);
460 }
461
462 safe_close(fd_lock);
463
464 /* send processed event back to libudev listeners */
465 udev_monitor_send_device(worker_monitor, NULL, dev);
466
467 skip:
468 log_debug("seq %llu processed", udev_device_get_seqnum(dev));
469
470 /* send udevd the result of the event execution */
471 r = worker_send_message(manager->worker_watch[WRITE_END]);
472 if (r < 0)
473 log_error_errno(r, "failed to send result of seq %llu to main daemon: %m",
474 udev_device_get_seqnum(dev));
475
476 dev = udev_device_unref(dev);
477
478 /* wait for more device messages from main udevd, or term signal */
479 while (dev == NULL) {
480 struct epoll_event ev[4];
481 int fdcount;
482 int i;
483
484 fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1);
485 if (fdcount < 0) {
486 if (errno == EINTR)
487 continue;
488 r = log_error_errno(errno, "failed to poll: %m");
489 goto out;
490 }
491
492 for (i = 0; i < fdcount; i++) {
493 if (ev[i].data.fd == fd_monitor && ev[i].events & EPOLLIN) {
494 dev = udev_monitor_receive_device(worker_monitor);
495 break;
496 } else if (ev[i].data.fd == fd_signal && ev[i].events & EPOLLIN) {
497 struct signalfd_siginfo fdsi;
498 ssize_t size;
499
500 size = read(fd_signal, &fdsi, sizeof(struct signalfd_siginfo));
501 if (size != sizeof(struct signalfd_siginfo))
502 continue;
503 switch (fdsi.ssi_signo) {
504 case SIGTERM:
505 goto out;
506 }
507 }
508 }
509 }
510 }
511 out:
512 udev_device_unref(dev);
513 manager_free(manager);
514 log_close();
515 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
516 }
517 case -1:
518 event->state = EVENT_QUEUED;
519 log_error_errno(errno, "fork of child failed: %m");
520 break;
521 default:
522 {
523 struct worker *worker;
524
525 r = worker_new(&worker, manager, worker_monitor, pid);
526 if (r < 0)
527 return;
528
529 worker_attach_event(worker, event);
530
531 log_debug("seq %llu forked new worker ["PID_FMT"]", udev_device_get_seqnum(event->dev), pid);
532 break;
533 }
534 }
535 }
536
537 static void event_run(Manager *manager, struct event *event) {
538 struct worker *worker;
539 Iterator i;
540
541 assert(manager);
542 assert(event);
543
544 HASHMAP_FOREACH(worker, manager->workers, i) {
545 ssize_t count;
546
547 if (worker->state != WORKER_IDLE)
548 continue;
549
550 count = udev_monitor_send_device(manager->monitor, worker->monitor, event->dev);
551 if (count < 0) {
552 log_error_errno(errno, "worker ["PID_FMT"] did not accept message %zi (%m), kill it",
553 worker->pid, count);
554 (void) kill(worker->pid, SIGKILL);
555 worker->state = WORKER_KILLED;
556 continue;
557 }
558 worker_attach_event(worker, event);
559 return;
560 }
561
562 if (hashmap_size(manager->workers) >= arg_children_max) {
563 if (arg_children_max > 1)
564 log_debug("maximum number (%i) of children reached", hashmap_size(manager->workers));
565 return;
566 }
567
568 /* start new worker and pass initial device */
569 worker_spawn(manager, event);
570 }
571
572 static int event_queue_insert(Manager *manager, struct udev_device *dev) {
573 struct event *event;
574 int r;
575
576 assert(manager);
577 assert(dev);
578
579 /* only one process can add events to the queue */
580 if (manager->pid == 0)
581 manager->pid = getpid_cached();
582
583 assert(manager->pid == getpid_cached());
584
585 event = new0(struct event, 1);
586 if (!event)
587 return -ENOMEM;
588
589 event->manager = manager;
590 event->dev = dev;
591 event->dev_kernel = udev_device_shallow_clone(dev);
592 udev_device_copy_properties(event->dev_kernel, dev);
593 event->seqnum = udev_device_get_seqnum(dev);
594 event->devpath = udev_device_get_devpath(dev);
595 event->devpath_len = strlen(event->devpath);
596 event->devpath_old = udev_device_get_devpath_old(dev);
597 event->devnum = udev_device_get_devnum(dev);
598 event->is_block = streq("block", udev_device_get_subsystem(dev));
599 event->ifindex = udev_device_get_ifindex(dev);
600
601 log_debug("seq %llu queued, '%s' '%s'", udev_device_get_seqnum(dev),
602 udev_device_get_action(dev), udev_device_get_subsystem(dev));
603
604 event->state = EVENT_QUEUED;
605
606 if (LIST_IS_EMPTY(manager->events)) {
607 r = touch("/run/udev/queue");
608 if (r < 0)
609 log_warning_errno(r, "could not touch /run/udev/queue: %m");
610 }
611
612 LIST_APPEND(event, manager->events, event);
613
614 return 0;
615 }
616
617 static void manager_kill_workers(Manager *manager) {
618 struct worker *worker;
619 Iterator i;
620
621 assert(manager);
622
623 HASHMAP_FOREACH(worker, manager->workers, i) {
624 if (worker->state == WORKER_KILLED)
625 continue;
626
627 worker->state = WORKER_KILLED;
628 (void) kill(worker->pid, SIGTERM);
629 }
630 }
631
632 /* lookup event for identical, parent, child device */
633 static bool is_devpath_busy(Manager *manager, struct event *event) {
634 struct event *loop_event;
635 size_t common;
636
637 /* check if queue contains events we depend on */
638 LIST_FOREACH(event, loop_event, manager->events) {
639 /* we already found a later event, earlier cannot block us, no need to check again */
640 if (loop_event->seqnum < event->delaying_seqnum)
641 continue;
642
643 /* event we checked earlier still exists, no need to check again */
644 if (loop_event->seqnum == event->delaying_seqnum)
645 return true;
646
647 /* found ourself, no later event can block us */
648 if (loop_event->seqnum >= event->seqnum)
649 break;
650
651 /* check major/minor */
652 if (major(event->devnum) != 0 && event->devnum == loop_event->devnum && event->is_block == loop_event->is_block)
653 return true;
654
655 /* check network device ifindex */
656 if (event->ifindex != 0 && event->ifindex == loop_event->ifindex)
657 return true;
658
659 /* check our old name */
660 if (event->devpath_old != NULL && streq(loop_event->devpath, event->devpath_old)) {
661 event->delaying_seqnum = loop_event->seqnum;
662 return true;
663 }
664
665 /* compare devpath */
666 common = MIN(loop_event->devpath_len, event->devpath_len);
667
668 /* one devpath is contained in the other? */
669 if (memcmp(loop_event->devpath, event->devpath, common) != 0)
670 continue;
671
672 /* identical device event found */
673 if (loop_event->devpath_len == event->devpath_len) {
674 /* devices names might have changed/swapped in the meantime */
675 if (major(event->devnum) != 0 && (event->devnum != loop_event->devnum || event->is_block != loop_event->is_block))
676 continue;
677 if (event->ifindex != 0 && event->ifindex != loop_event->ifindex)
678 continue;
679 event->delaying_seqnum = loop_event->seqnum;
680 return true;
681 }
682
683 /* parent device event found */
684 if (event->devpath[common] == '/') {
685 event->delaying_seqnum = loop_event->seqnum;
686 return true;
687 }
688
689 /* child device event found */
690 if (loop_event->devpath[common] == '/') {
691 event->delaying_seqnum = loop_event->seqnum;
692 return true;
693 }
694
695 /* no matching device */
696 continue;
697 }
698
699 return false;
700 }
701
702 static int on_exit_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
703 Manager *manager = userdata;
704
705 assert(manager);
706
707 log_error_errno(ETIMEDOUT, "giving up waiting for workers to finish");
708
709 sd_event_exit(manager->event, -ETIMEDOUT);
710
711 return 1;
712 }
713
714 static void manager_exit(Manager *manager) {
715 uint64_t usec;
716 int r;
717
718 assert(manager);
719
720 manager->exit = true;
721
722 sd_notify(false,
723 "STOPPING=1\n"
724 "STATUS=Starting shutdown...");
725
726 /* close sources of new events and discard buffered events */
727 manager->ctrl_event = sd_event_source_unref(manager->ctrl_event);
728 manager->ctrl = udev_ctrl_unref(manager->ctrl);
729
730 manager->inotify_event = sd_event_source_unref(manager->inotify_event);
731 manager->fd_inotify = safe_close(manager->fd_inotify);
732
733 manager->uevent_event = sd_event_source_unref(manager->uevent_event);
734 manager->monitor = udev_monitor_unref(manager->monitor);
735
736 /* discard queued events and kill workers */
737 event_queue_cleanup(manager, EVENT_QUEUED);
738 manager_kill_workers(manager);
739
740 assert_se(sd_event_now(manager->event, CLOCK_MONOTONIC, &usec) >= 0);
741
742 r = sd_event_add_time(manager->event, NULL, CLOCK_MONOTONIC,
743 usec + 30 * USEC_PER_SEC, USEC_PER_SEC, on_exit_timeout, manager);
744 if (r < 0)
745 return;
746 }
747
748 /* reload requested, HUP signal received, rules changed, builtin changed */
749 static void manager_reload(Manager *manager) {
750
751 assert(manager);
752
753 sd_notify(false,
754 "RELOADING=1\n"
755 "STATUS=Flushing configuration...");
756
757 manager_kill_workers(manager);
758 manager->rules = udev_rules_unref(manager->rules);
759 udev_builtin_exit();
760
761 sd_notifyf(false,
762 "READY=1\n"
763 "STATUS=Processing with %u children at max", arg_children_max);
764 }
765
766 static int on_kill_workers_event(sd_event_source *s, uint64_t usec, void *userdata) {
767 Manager *manager = userdata;
768
769 assert(manager);
770
771 log_debug("Cleanup idle workers");
772 manager_kill_workers(manager);
773
774 return 1;
775 }
776
777 static int manager_enable_kill_workers_event(Manager *manager) {
778 int enabled, r;
779
780 assert(manager);
781
782 if (!manager->kill_workers_event)
783 goto create_new;
784
785 r = sd_event_source_get_enabled(manager->kill_workers_event, &enabled);
786 if (r < 0) {
787 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");
788 manager->kill_workers_event = sd_event_source_unref(manager->kill_workers_event);
789 goto create_new;
790 }
791
792 if (enabled == SD_EVENT_ONESHOT)
793 return 0;
794
795 r = sd_event_source_set_time(manager->kill_workers_event, now(CLOCK_MONOTONIC) + 3 * USEC_PER_SEC);
796 if (r < 0) {
797 log_debug_errno(r, "Failed to set time to event source for killing idle workers, trying to create new event source: %m");
798 manager->kill_workers_event = sd_event_source_unref(manager->kill_workers_event);
799 goto create_new;
800 }
801
802 r = sd_event_source_set_enabled(manager->kill_workers_event, SD_EVENT_ONESHOT);
803 if (r < 0) {
804 log_debug_errno(r, "Failed to enable event source for killing idle workers, trying to create new event source: %m");
805 manager->kill_workers_event = sd_event_source_unref(manager->kill_workers_event);
806 goto create_new;
807 }
808
809 return 0;
810
811 create_new:
812 r = sd_event_add_time(manager->event, &manager->kill_workers_event, CLOCK_MONOTONIC,
813 now(CLOCK_MONOTONIC) + 3 * USEC_PER_SEC, USEC_PER_SEC, on_kill_workers_event, manager);
814 if (r < 0)
815 return log_warning_errno(r, "Failed to create timer event for killing idle workers: %m");
816
817 return 0;
818 }
819
820 static int manager_disable_kill_workers_event(Manager *manager) {
821 int r;
822
823 if (!manager->kill_workers_event)
824 return 0;
825
826 r = sd_event_source_set_enabled(manager->kill_workers_event, SD_EVENT_OFF);
827 if (r < 0)
828 return log_warning_errno(r, "Failed to disable event source for cleaning up idle workers, ignoring: %m");
829
830 return 0;
831 }
832
833 static void event_queue_start(Manager *manager) {
834 struct event *event;
835 usec_t usec;
836
837 assert(manager);
838
839 if (LIST_IS_EMPTY(manager->events) ||
840 manager->exit || manager->stop_exec_queue)
841 return;
842
843 assert_se(sd_event_now(manager->event, CLOCK_MONOTONIC, &usec) >= 0);
844 /* check for changed config, every 3 seconds at most */
845 if (manager->last_usec == 0 ||
846 (usec - manager->last_usec) > 3 * USEC_PER_SEC) {
847 if (udev_rules_check_timestamp(manager->rules) ||
848 udev_builtin_validate())
849 manager_reload(manager);
850
851 manager->last_usec = usec;
852 }
853
854 (void) manager_disable_kill_workers_event(manager);
855
856 udev_builtin_init();
857
858 if (!manager->rules) {
859 manager->rules = udev_rules_new(arg_resolve_names);
860 if (!manager->rules)
861 return;
862 }
863
864 LIST_FOREACH(event,event,manager->events) {
865 if (event->state != EVENT_QUEUED)
866 continue;
867
868 /* do not start event if parent or child event is still running */
869 if (is_devpath_busy(manager, event))
870 continue;
871
872 event_run(manager, event);
873 }
874 }
875
876 static void event_queue_cleanup(Manager *manager, enum event_state match_type) {
877 struct event *event, *tmp;
878
879 LIST_FOREACH_SAFE(event, event, tmp, manager->events) {
880 if (match_type != EVENT_UNDEF && match_type != event->state)
881 continue;
882
883 event_free(event);
884 }
885 }
886
887 static int on_worker(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
888 Manager *manager = userdata;
889
890 assert(manager);
891
892 for (;;) {
893 struct worker_message msg;
894 struct iovec iovec = {
895 .iov_base = &msg,
896 .iov_len = sizeof(msg),
897 };
898 union {
899 struct cmsghdr cmsghdr;
900 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
901 } control = {};
902 struct msghdr msghdr = {
903 .msg_iov = &iovec,
904 .msg_iovlen = 1,
905 .msg_control = &control,
906 .msg_controllen = sizeof(control),
907 };
908 struct cmsghdr *cmsg;
909 ssize_t size;
910 struct ucred *ucred = NULL;
911 struct worker *worker;
912
913 size = recvmsg(fd, &msghdr, MSG_DONTWAIT);
914 if (size < 0) {
915 if (errno == EINTR)
916 continue;
917 else if (errno == EAGAIN)
918 /* nothing more to read */
919 break;
920
921 return log_error_errno(errno, "failed to receive message: %m");
922 } else if (size != sizeof(struct worker_message)) {
923 log_warning_errno(EIO, "ignoring worker message with invalid size %zi bytes", size);
924 continue;
925 }
926
927 CMSG_FOREACH(cmsg, &msghdr) {
928 if (cmsg->cmsg_level == SOL_SOCKET &&
929 cmsg->cmsg_type == SCM_CREDENTIALS &&
930 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
931 ucred = (struct ucred*) CMSG_DATA(cmsg);
932 }
933
934 if (!ucred || ucred->pid <= 0) {
935 log_warning_errno(EIO, "ignoring worker message without valid PID");
936 continue;
937 }
938
939 /* lookup worker who sent the signal */
940 worker = hashmap_get(manager->workers, PID_TO_PTR(ucred->pid));
941 if (!worker) {
942 log_debug("worker ["PID_FMT"] returned, but is no longer tracked", ucred->pid);
943 continue;
944 }
945
946 if (worker->state != WORKER_KILLED)
947 worker->state = WORKER_IDLE;
948
949 /* worker returned */
950 event_free(worker->event);
951 }
952
953 /* we have free workers, try to schedule events */
954 event_queue_start(manager);
955
956 return 1;
957 }
958
959 static int on_uevent(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
960 Manager *manager = userdata;
961 struct udev_device *dev;
962 int r;
963
964 assert(manager);
965
966 dev = udev_monitor_receive_device(manager->monitor);
967 if (dev) {
968 udev_device_ensure_usec_initialized(dev, NULL);
969 r = event_queue_insert(manager, dev);
970 if (r < 0)
971 udev_device_unref(dev);
972 else
973 /* we have fresh events, try to schedule them */
974 event_queue_start(manager);
975 }
976
977 return 1;
978 }
979
980 /* receive the udevd message from userspace */
981 static int on_ctrl_msg(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
982 Manager *manager = userdata;
983 _cleanup_(udev_ctrl_connection_unrefp) struct udev_ctrl_connection *ctrl_conn = NULL;
984 _cleanup_(udev_ctrl_msg_unrefp) struct udev_ctrl_msg *ctrl_msg = NULL;
985 const char *str;
986 int i, r;
987
988 assert(manager);
989
990 ctrl_conn = udev_ctrl_get_connection(manager->ctrl);
991 if (!ctrl_conn)
992 return 1;
993
994 ctrl_msg = udev_ctrl_receive_msg(ctrl_conn);
995 if (!ctrl_msg)
996 return 1;
997
998 i = udev_ctrl_get_set_log_level(ctrl_msg);
999 if (i >= 0) {
1000 log_debug("udevd message (SET_LOG_LEVEL) received, log_priority=%i", i);
1001 log_set_max_level(i);
1002 manager_kill_workers(manager);
1003 }
1004
1005 if (udev_ctrl_get_stop_exec_queue(ctrl_msg) > 0) {
1006 log_debug("udevd message (STOP_EXEC_QUEUE) received");
1007 manager->stop_exec_queue = true;
1008 }
1009
1010 if (udev_ctrl_get_start_exec_queue(ctrl_msg) > 0) {
1011 log_debug("udevd message (START_EXEC_QUEUE) received");
1012 manager->stop_exec_queue = false;
1013 event_queue_start(manager);
1014 }
1015
1016 if (udev_ctrl_get_reload(ctrl_msg) > 0) {
1017 log_debug("udevd message (RELOAD) received");
1018 manager_reload(manager);
1019 }
1020
1021 str = udev_ctrl_get_set_env(ctrl_msg);
1022 if (str) {
1023 _cleanup_free_ char *key = NULL, *val = NULL, *old_key = NULL, *old_val = NULL;
1024 char *eq;
1025
1026 eq = strchr(str, '=');
1027 if (!eq) {
1028 log_error("Invalid key format '%s'", str);
1029 return 1;
1030 }
1031
1032 key = strndup(str, eq - str);
1033 if (!key) {
1034 log_oom();
1035 return 1;
1036 }
1037
1038 old_val = hashmap_remove2(manager->properties, key, (void **) &old_key);
1039
1040 r = hashmap_ensure_allocated(&manager->properties, &string_hash_ops);
1041 if (r < 0) {
1042 log_oom();
1043 return 1;
1044 }
1045
1046 eq++;
1047 if (!isempty(eq)) {
1048 log_debug("udevd message (ENV) received, unset '%s'", key);
1049
1050 r = hashmap_put(manager->properties, key, NULL);
1051 if (r < 0) {
1052 log_oom();
1053 return 1;
1054 }
1055 } else {
1056 val = strdup(eq);
1057 if (!val) {
1058 log_oom();
1059 return 1;
1060 }
1061
1062 log_debug("udevd message (ENV) received, set '%s=%s'", key, val);
1063
1064 r = hashmap_put(manager->properties, key, val);
1065 if (r < 0) {
1066 log_oom();
1067 return 1;
1068 }
1069 }
1070
1071 key = val = NULL;
1072 manager_kill_workers(manager);
1073 }
1074
1075 i = udev_ctrl_get_set_children_max(ctrl_msg);
1076 if (i >= 0) {
1077 log_debug("udevd message (SET_MAX_CHILDREN) received, children_max=%i", i);
1078 arg_children_max = i;
1079
1080 (void) sd_notifyf(false,
1081 "READY=1\n"
1082 "STATUS=Processing with %u children at max", arg_children_max);
1083 }
1084
1085 if (udev_ctrl_get_ping(ctrl_msg) > 0)
1086 log_debug("udevd message (SYNC) received");
1087
1088 if (udev_ctrl_get_exit(ctrl_msg) > 0) {
1089 log_debug("udevd message (EXIT) received");
1090 manager_exit(manager);
1091 /* keep reference to block the client until we exit
1092 TODO: deal with several blocking exit requests */
1093 manager->ctrl_conn_blocking = udev_ctrl_connection_ref(ctrl_conn);
1094 }
1095
1096 return 1;
1097 }
1098
1099 static int synthesize_change(sd_device *dev) {
1100 const char *subsystem, *sysname, *devname, *syspath, *devtype;
1101 char filename[PATH_MAX];
1102 int r;
1103
1104 r = sd_device_get_subsystem(dev, &subsystem);
1105 if (r < 0)
1106 return r;
1107
1108 r = sd_device_get_sysname(dev, &sysname);
1109 if (r < 0)
1110 return r;
1111
1112 r = sd_device_get_devname(dev, &devname);
1113 if (r < 0)
1114 return r;
1115
1116 r = sd_device_get_syspath(dev, &syspath);
1117 if (r < 0)
1118 return r;
1119
1120 r = sd_device_get_devtype(dev, &devtype);
1121 if (r < 0)
1122 return r;
1123
1124 if (streq_ptr("block", subsystem) &&
1125 streq_ptr("disk", devtype) &&
1126 !startswith(sysname, "dm-")) {
1127 _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
1128 bool part_table_read = false, has_partitions = false;
1129 sd_device *d;
1130 int fd;
1131
1132 /*
1133 * Try to re-read the partition table. This only succeeds if
1134 * none of the devices is busy. The kernel returns 0 if no
1135 * partition table is found, and we will not get an event for
1136 * the disk.
1137 */
1138 fd = open(devname, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK);
1139 if (fd >= 0) {
1140 r = flock(fd, LOCK_EX|LOCK_NB);
1141 if (r >= 0)
1142 r = ioctl(fd, BLKRRPART, 0);
1143
1144 close(fd);
1145 if (r >= 0)
1146 part_table_read = true;
1147 }
1148
1149 /* search for partitions */
1150 r = sd_device_enumerator_new(&e);
1151 if (r < 0)
1152 return r;
1153
1154 r = sd_device_enumerator_allow_uninitialized(e);
1155 if (r < 0)
1156 return r;
1157
1158 r = sd_device_enumerator_add_match_parent(e, dev);
1159 if (r < 0)
1160 return r;
1161
1162 r = sd_device_enumerator_add_match_subsystem(e, "block", true);
1163 if (r < 0)
1164 return r;
1165
1166 FOREACH_DEVICE(e, d) {
1167 const char *t;
1168
1169 if (sd_device_get_devtype(d, &t) < 0 ||
1170 !streq("partition", t))
1171 continue;
1172
1173 has_partitions = true;
1174 break;
1175 }
1176
1177 /*
1178 * We have partitions and re-read the table, the kernel already sent
1179 * out a "change" event for the disk, and "remove/add" for all
1180 * partitions.
1181 */
1182 if (part_table_read && has_partitions)
1183 return 0;
1184
1185 /*
1186 * We have partitions but re-reading the partition table did not
1187 * work, synthesize "change" for the disk and all partitions.
1188 */
1189 log_debug("Device '%s' is closed, synthesising 'change'", devname);
1190 strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
1191 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1192
1193 FOREACH_DEVICE(e, d) {
1194 const char *t, *n, *s;
1195
1196 if (sd_device_get_devtype(d, &t) < 0 ||
1197 !streq("partition", t))
1198 continue;
1199
1200 if (sd_device_get_devname(d, &n) < 0 ||
1201 sd_device_get_syspath(d, &s) < 0)
1202 continue;
1203
1204 log_debug("Device '%s' is closed, synthesising partition '%s' 'change'", devname, n);
1205 strscpyl(filename, sizeof(filename), s, "/uevent", NULL);
1206 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1207 }
1208
1209 return 0;
1210 }
1211
1212 log_debug("Device %s is closed, synthesising 'change'", devname);
1213 strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
1214 write_string_file(filename, "change", WRITE_STRING_FILE_DISABLE_BUFFER);
1215
1216 return 0;
1217 }
1218
1219 static int on_inotify(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1220 Manager *manager = userdata;
1221 union inotify_event_buffer buffer;
1222 struct inotify_event *e;
1223 ssize_t l;
1224
1225 assert(manager);
1226
1227 (void) manager_disable_kill_workers_event(manager);
1228
1229 l = read(fd, &buffer, sizeof(buffer));
1230 if (l < 0) {
1231 if (IN_SET(errno, EAGAIN, EINTR))
1232 return 1;
1233
1234 return log_error_errno(errno, "Failed to read inotify fd: %m");
1235 }
1236
1237 FOREACH_INOTIFY_EVENT(e, buffer, l) {
1238 _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
1239 const char *devnode;
1240
1241 if (udev_watch_lookup(e->wd, &dev) <= 0)
1242 continue;
1243
1244 if (sd_device_get_devname(dev, &devnode) < 0)
1245 continue;
1246
1247 log_device_debug(dev, "Inotify event: %x for %s", e->mask, devnode);
1248 if (e->mask & IN_CLOSE_WRITE)
1249 synthesize_change(dev);
1250 else if (e->mask & IN_IGNORED)
1251 udev_watch_end(dev);
1252 }
1253
1254 return 1;
1255 }
1256
1257 static int on_sigterm(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1258 Manager *manager = userdata;
1259
1260 assert(manager);
1261
1262 manager_exit(manager);
1263
1264 return 1;
1265 }
1266
1267 static int on_sighup(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1268 Manager *manager = userdata;
1269
1270 assert(manager);
1271
1272 manager_reload(manager);
1273
1274 return 1;
1275 }
1276
1277 static int on_sigchld(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1278 Manager *manager = userdata;
1279
1280 assert(manager);
1281
1282 for (;;) {
1283 pid_t pid;
1284 int status;
1285 struct worker *worker;
1286
1287 pid = waitpid(-1, &status, WNOHANG);
1288 if (pid <= 0)
1289 break;
1290
1291 worker = hashmap_get(manager->workers, PID_TO_PTR(pid));
1292 if (!worker) {
1293 log_warning("worker ["PID_FMT"] is unknown, ignoring", pid);
1294 continue;
1295 }
1296
1297 if (WIFEXITED(status)) {
1298 if (WEXITSTATUS(status) == 0)
1299 log_debug("worker ["PID_FMT"] exited", pid);
1300 else
1301 log_warning("worker ["PID_FMT"] exited with return code %i", pid, WEXITSTATUS(status));
1302 } else if (WIFSIGNALED(status)) {
1303 log_warning("worker ["PID_FMT"] terminated by signal %i (%s)", pid, WTERMSIG(status), signal_to_string(WTERMSIG(status)));
1304 } else if (WIFSTOPPED(status)) {
1305 log_info("worker ["PID_FMT"] stopped", pid);
1306 continue;
1307 } else if (WIFCONTINUED(status)) {
1308 log_info("worker ["PID_FMT"] continued", pid);
1309 continue;
1310 } else
1311 log_warning("worker ["PID_FMT"] exit with status 0x%04x", pid, status);
1312
1313 if ((!WIFEXITED(status) || WEXITSTATUS(status) != 0) && worker->event) {
1314 log_error("worker ["PID_FMT"] failed while handling '%s'", pid, worker->event->devpath);
1315 /* delete state from disk */
1316 udev_device_delete_db(worker->event->dev);
1317 udev_device_tag_index(worker->event->dev, NULL, false);
1318 /* forward kernel event without amending it */
1319 udev_monitor_send_device(manager->monitor, NULL, worker->event->dev_kernel);
1320 }
1321
1322 worker_free(worker);
1323 }
1324
1325 /* we can start new workers, try to schedule events */
1326 event_queue_start(manager);
1327
1328 /* Disable unnecessary cleanup event */
1329 if (hashmap_isempty(manager->workers) && manager->kill_workers_event)
1330 (void) sd_event_source_set_enabled(manager->kill_workers_event, SD_EVENT_OFF);
1331
1332 return 1;
1333 }
1334
1335 static int on_post(sd_event_source *s, void *userdata) {
1336 Manager *manager = userdata;
1337
1338 assert(manager);
1339
1340 if (!LIST_IS_EMPTY(manager->events))
1341 return 1;
1342
1343 /* There are no pending events. Let's cleanup idle process. */
1344
1345 if (!hashmap_isempty(manager->workers)) {
1346 /* There are idle workers */
1347 (void) manager_enable_kill_workers_event(manager);
1348 return 1;
1349 }
1350
1351 /* There are no idle workers. */
1352
1353 if (manager->exit)
1354 return sd_event_exit(manager->event, 0);
1355
1356 if (manager->cgroup)
1357 /* cleanup possible left-over processes in our cgroup */
1358 (void) cg_kill(SYSTEMD_CGROUP_CONTROLLER, manager->cgroup, SIGKILL, CGROUP_IGNORE_SELF, NULL, NULL, NULL);
1359
1360 return 1;
1361 }
1362
1363 static int listen_fds(int *rctrl, int *rnetlink) {
1364 int ctrl_fd = -1, netlink_fd = -1;
1365 int fd, n, r;
1366
1367 assert(rctrl);
1368 assert(rnetlink);
1369
1370 n = sd_listen_fds(true);
1371 if (n < 0)
1372 return n;
1373
1374 for (fd = SD_LISTEN_FDS_START; fd < n + SD_LISTEN_FDS_START; fd++) {
1375 if (sd_is_socket(fd, AF_LOCAL, SOCK_SEQPACKET, -1)) {
1376 if (ctrl_fd >= 0)
1377 return -EINVAL;
1378 ctrl_fd = fd;
1379 continue;
1380 }
1381
1382 if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1)) {
1383 if (netlink_fd >= 0)
1384 return -EINVAL;
1385 netlink_fd = fd;
1386 continue;
1387 }
1388
1389 return -EINVAL;
1390 }
1391
1392 if (ctrl_fd < 0) {
1393 _cleanup_(udev_ctrl_unrefp) struct udev_ctrl *ctrl = NULL;
1394
1395 ctrl = udev_ctrl_new();
1396 if (!ctrl)
1397 return log_error_errno(EINVAL, "error initializing udev control socket");
1398
1399 r = udev_ctrl_enable_receiving(ctrl);
1400 if (r < 0)
1401 return log_error_errno(EINVAL, "error binding udev control socket");
1402
1403 fd = udev_ctrl_get_fd(ctrl);
1404 if (fd < 0)
1405 return log_error_errno(EIO, "could not get ctrl fd");
1406
1407 ctrl_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
1408 if (ctrl_fd < 0)
1409 return log_error_errno(errno, "could not dup ctrl fd: %m");
1410 }
1411
1412 if (netlink_fd < 0) {
1413 _cleanup_(udev_monitor_unrefp) struct udev_monitor *monitor = NULL;
1414
1415 monitor = udev_monitor_new_from_netlink(NULL, "kernel");
1416 if (!monitor)
1417 return log_error_errno(EINVAL, "error initializing netlink socket");
1418
1419 (void) udev_monitor_set_receive_buffer_size(monitor, 128 * 1024 * 1024);
1420
1421 r = udev_monitor_enable_receiving(monitor);
1422 if (r < 0)
1423 return log_error_errno(EINVAL, "error binding netlink socket");
1424
1425 fd = udev_monitor_get_fd(monitor);
1426 if (fd < 0)
1427 return log_error_errno(netlink_fd, "could not get uevent fd: %m");
1428
1429 netlink_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
1430 if (netlink_fd < 0)
1431 return log_error_errno(errno, "could not dup netlink fd: %m");
1432 }
1433
1434 *rctrl = ctrl_fd;
1435 *rnetlink = netlink_fd;
1436
1437 return 0;
1438 }
1439
1440 /*
1441 * read the kernel command line, in case we need to get into debug mode
1442 * udev.log_priority=<level> syslog priority
1443 * udev.children_max=<number of workers> events are fully serialized if set to 1
1444 * udev.exec_delay=<number of seconds> delay execution of every executed program
1445 * udev.event_timeout=<number of seconds> seconds to wait before terminating an event
1446 */
1447 static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
1448 int r = 0;
1449
1450 assert(key);
1451
1452 if (!value)
1453 return 0;
1454
1455 if (proc_cmdline_key_streq(key, "udev.log_priority")) {
1456
1457 if (proc_cmdline_value_missing(key, value))
1458 return 0;
1459
1460 r = util_log_priority(value);
1461 if (r >= 0)
1462 log_set_max_level(r);
1463
1464 } else if (proc_cmdline_key_streq(key, "udev.event_timeout")) {
1465
1466 if (proc_cmdline_value_missing(key, value))
1467 return 0;
1468
1469 r = safe_atou64(value, &arg_event_timeout_usec);
1470 if (r >= 0) {
1471 arg_event_timeout_usec *= USEC_PER_SEC;
1472 arg_event_timeout_warn_usec = (arg_event_timeout_usec / 3) ? : 1;
1473 }
1474
1475 } else if (proc_cmdline_key_streq(key, "udev.children_max")) {
1476
1477 if (proc_cmdline_value_missing(key, value))
1478 return 0;
1479
1480 r = safe_atou(value, &arg_children_max);
1481
1482 } else if (proc_cmdline_key_streq(key, "udev.exec_delay")) {
1483
1484 if (proc_cmdline_value_missing(key, value))
1485 return 0;
1486
1487 r = safe_atoi(value, &arg_exec_delay);
1488
1489 } else if (startswith(key, "udev."))
1490 log_warning("Unknown udev kernel command line option \"%s\"", key);
1491
1492 if (r < 0)
1493 log_warning_errno(r, "Failed to parse \"%s=%s\", ignoring: %m", key, value);
1494
1495 return 0;
1496 }
1497
1498 static int help(void) {
1499 _cleanup_free_ char *link = NULL;
1500 int r;
1501
1502 r = terminal_urlify_man("systemd-udevd.service", "8", &link);
1503 if (r < 0)
1504 return log_oom();
1505
1506 printf("%s [OPTIONS...]\n\n"
1507 "Manages devices.\n\n"
1508 " -h --help Print this message\n"
1509 " -V --version Print version of the program\n"
1510 " -d --daemon Detach and run in the background\n"
1511 " -D --debug Enable debug output\n"
1512 " -c --children-max=INT Set maximum number of workers\n"
1513 " -e --exec-delay=SECONDS Seconds to wait before executing RUN=\n"
1514 " -t --event-timeout=SECONDS Seconds to wait before terminating an event\n"
1515 " -N --resolve-names=early|late|never\n"
1516 " When to resolve users and groups\n"
1517 "\nSee the %s for details.\n"
1518 , program_invocation_short_name
1519 , link
1520 );
1521
1522 return 0;
1523 }
1524
1525 static int parse_argv(int argc, char *argv[]) {
1526 static const struct option options[] = {
1527 { "daemon", no_argument, NULL, 'd' },
1528 { "debug", no_argument, NULL, 'D' },
1529 { "children-max", required_argument, NULL, 'c' },
1530 { "exec-delay", required_argument, NULL, 'e' },
1531 { "event-timeout", required_argument, NULL, 't' },
1532 { "resolve-names", required_argument, NULL, 'N' },
1533 { "help", no_argument, NULL, 'h' },
1534 { "version", no_argument, NULL, 'V' },
1535 {}
1536 };
1537
1538 int c;
1539
1540 assert(argc >= 0);
1541 assert(argv);
1542
1543 while ((c = getopt_long(argc, argv, "c:de:Dt:N:hV", options, NULL)) >= 0) {
1544 int r;
1545
1546 switch (c) {
1547
1548 case 'd':
1549 arg_daemonize = true;
1550 break;
1551 case 'c':
1552 r = safe_atou(optarg, &arg_children_max);
1553 if (r < 0)
1554 log_warning("Invalid --children-max ignored: %s", optarg);
1555 break;
1556 case 'e':
1557 r = safe_atoi(optarg, &arg_exec_delay);
1558 if (r < 0)
1559 log_warning("Invalid --exec-delay ignored: %s", optarg);
1560 break;
1561 case 't':
1562 r = safe_atou64(optarg, &arg_event_timeout_usec);
1563 if (r < 0)
1564 log_warning("Invalid --event-timeout ignored: %s", optarg);
1565 else {
1566 arg_event_timeout_usec *= USEC_PER_SEC;
1567 arg_event_timeout_warn_usec = (arg_event_timeout_usec / 3) ? : 1;
1568 }
1569 break;
1570 case 'D':
1571 arg_debug = true;
1572 break;
1573 case 'N':
1574 if (streq(optarg, "early")) {
1575 arg_resolve_names = 1;
1576 } else if (streq(optarg, "late")) {
1577 arg_resolve_names = 0;
1578 } else if (streq(optarg, "never")) {
1579 arg_resolve_names = -1;
1580 } else {
1581 log_error("resolve-names must be early, late or never");
1582 return 0;
1583 }
1584 break;
1585 case 'h':
1586 return help();
1587 case 'V':
1588 printf("%s\n", PACKAGE_VERSION);
1589 return 0;
1590 case '?':
1591 return -EINVAL;
1592 default:
1593 assert_not_reached("Unhandled option");
1594
1595 }
1596 }
1597
1598 return 1;
1599 }
1600
1601 static int manager_new(Manager **ret, int fd_ctrl, int fd_uevent, const char *cgroup) {
1602 _cleanup_(manager_freep) Manager *manager = NULL;
1603 int r, fd_worker;
1604
1605 assert(ret);
1606 assert(fd_ctrl >= 0);
1607 assert(fd_uevent >= 0);
1608
1609 manager = new0(Manager, 1);
1610 if (!manager)
1611 return log_oom();
1612
1613 manager->fd_inotify = -1;
1614 manager->worker_watch[WRITE_END] = -1;
1615 manager->worker_watch[READ_END] = -1;
1616
1617 udev_builtin_init();
1618
1619 manager->rules = udev_rules_new(arg_resolve_names);
1620 if (!manager->rules)
1621 return log_error_errno(ENOMEM, "error reading rules");
1622
1623 LIST_HEAD_INIT(manager->events);
1624
1625 manager->cgroup = cgroup;
1626
1627 manager->ctrl = udev_ctrl_new_from_fd(fd_ctrl);
1628 if (!manager->ctrl)
1629 return log_error_errno(EINVAL, "error taking over udev control socket");
1630
1631 manager->monitor = udev_monitor_new_from_netlink_fd(NULL, "kernel", fd_uevent);
1632 if (!manager->monitor)
1633 return log_error_errno(EINVAL, "error taking over netlink socket");
1634
1635 /* unnamed socket from workers to the main daemon */
1636 r = socketpair(AF_LOCAL, SOCK_DGRAM|SOCK_CLOEXEC, 0, manager->worker_watch);
1637 if (r < 0)
1638 return log_error_errno(errno, "error creating socketpair: %m");
1639
1640 fd_worker = manager->worker_watch[READ_END];
1641
1642 r = setsockopt_int(fd_worker, SOL_SOCKET, SO_PASSCRED, true);
1643 if (r < 0)
1644 return log_error_errno(r, "could not enable SO_PASSCRED: %m");
1645
1646 r = udev_watch_init();
1647 if (r < 0)
1648 return log_error_errno(r, "Failed to create inotify descriptor: %m");
1649 manager->fd_inotify = r;
1650
1651 udev_watch_restore();
1652
1653 /* block and listen to all signals on signalfd */
1654 assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, SIGHUP, SIGCHLD, -1) >= 0);
1655
1656 r = sd_event_default(&manager->event);
1657 if (r < 0)
1658 return log_error_errno(r, "could not allocate event loop: %m");
1659
1660 r = sd_event_add_signal(manager->event, NULL, SIGINT, on_sigterm, manager);
1661 if (r < 0)
1662 return log_error_errno(r, "error creating sigint event source: %m");
1663
1664 r = sd_event_add_signal(manager->event, NULL, SIGTERM, on_sigterm, manager);
1665 if (r < 0)
1666 return log_error_errno(r, "error creating sigterm event source: %m");
1667
1668 r = sd_event_add_signal(manager->event, NULL, SIGHUP, on_sighup, manager);
1669 if (r < 0)
1670 return log_error_errno(r, "error creating sighup event source: %m");
1671
1672 r = sd_event_add_signal(manager->event, NULL, SIGCHLD, on_sigchld, manager);
1673 if (r < 0)
1674 return log_error_errno(r, "error creating sigchld event source: %m");
1675
1676 r = sd_event_set_watchdog(manager->event, true);
1677 if (r < 0)
1678 return log_error_errno(r, "error creating watchdog event source: %m");
1679
1680 r = sd_event_add_io(manager->event, &manager->ctrl_event, fd_ctrl, EPOLLIN, on_ctrl_msg, manager);
1681 if (r < 0)
1682 return log_error_errno(r, "error creating ctrl event source: %m");
1683
1684 /* This needs to be after the inotify and uevent handling, to make sure
1685 * that the ping is send back after fully processing the pending uevents
1686 * (including the synthetic ones we may create due to inotify events).
1687 */
1688 r = sd_event_source_set_priority(manager->ctrl_event, SD_EVENT_PRIORITY_IDLE);
1689 if (r < 0)
1690 return log_error_errno(r, "cold not set IDLE event priority for ctrl event source: %m");
1691
1692 r = sd_event_add_io(manager->event, &manager->inotify_event, manager->fd_inotify, EPOLLIN, on_inotify, manager);
1693 if (r < 0)
1694 return log_error_errno(r, "error creating inotify event source: %m");
1695
1696 r = sd_event_add_io(manager->event, &manager->uevent_event, fd_uevent, EPOLLIN, on_uevent, manager);
1697 if (r < 0)
1698 return log_error_errno(r, "error creating uevent event source: %m");
1699
1700 r = sd_event_add_io(manager->event, NULL, fd_worker, EPOLLIN, on_worker, manager);
1701 if (r < 0)
1702 return log_error_errno(r, "error creating worker event source: %m");
1703
1704 r = sd_event_add_post(manager->event, NULL, on_post, manager);
1705 if (r < 0)
1706 return log_error_errno(r, "error creating post event source: %m");
1707
1708 *ret = TAKE_PTR(manager);
1709
1710 return 0;
1711 }
1712
1713 static int run(int fd_ctrl, int fd_uevent, const char *cgroup) {
1714 _cleanup_(manager_freep) Manager *manager = NULL;
1715 int r;
1716
1717 r = manager_new(&manager, fd_ctrl, fd_uevent, cgroup);
1718 if (r < 0) {
1719 r = log_error_errno(r, "failed to allocate manager object: %m");
1720 goto exit;
1721 }
1722
1723 r = udev_rules_apply_static_dev_perms(manager->rules);
1724 if (r < 0)
1725 log_error_errno(r, "failed to apply permissions on static device nodes: %m");
1726
1727 (void) sd_notifyf(false,
1728 "READY=1\n"
1729 "STATUS=Processing with %u children at max", arg_children_max);
1730
1731 r = sd_event_loop(manager->event);
1732 if (r < 0) {
1733 log_error_errno(r, "event loop failed: %m");
1734 goto exit;
1735 }
1736
1737 sd_event_get_exit_code(manager->event, &r);
1738
1739 exit:
1740 sd_notify(false,
1741 "STOPPING=1\n"
1742 "STATUS=Shutting down...");
1743 if (manager)
1744 udev_ctrl_cleanup(manager->ctrl);
1745 return r;
1746 }
1747
1748 int main(int argc, char *argv[]) {
1749 _cleanup_free_ char *cgroup = NULL;
1750 int fd_ctrl = -1, fd_uevent = -1;
1751 int r;
1752
1753 log_set_target(LOG_TARGET_AUTO);
1754 udev_parse_config();
1755 log_parse_environment();
1756 log_open();
1757
1758 r = parse_argv(argc, argv);
1759 if (r <= 0)
1760 goto exit;
1761
1762 r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX);
1763 if (r < 0)
1764 log_warning_errno(r, "failed to parse kernel command line, ignoring: %m");
1765
1766 if (arg_debug) {
1767 log_set_target(LOG_TARGET_CONSOLE);
1768 log_set_max_level(LOG_DEBUG);
1769 }
1770
1771 log_set_max_level_realm(LOG_REALM_SYSTEMD, log_get_max_level());
1772
1773 r = must_be_root();
1774 if (r < 0)
1775 goto exit;
1776
1777 if (arg_children_max == 0) {
1778 cpu_set_t cpu_set;
1779 unsigned long mem_limit;
1780
1781 arg_children_max = 8;
1782
1783 if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set) == 0)
1784 arg_children_max += CPU_COUNT(&cpu_set) * 8;
1785
1786 mem_limit = physical_memory() / (128LU*1024*1024);
1787 arg_children_max = MAX(10U, MIN(arg_children_max, mem_limit));
1788
1789 log_debug("set children_max to %u", arg_children_max);
1790 }
1791
1792 /* set umask before creating any file/directory */
1793 r = chdir("/");
1794 if (r < 0) {
1795 r = log_error_errno(errno, "could not change dir to /: %m");
1796 goto exit;
1797 }
1798
1799 umask(022);
1800
1801 r = mac_selinux_init();
1802 if (r < 0) {
1803 log_error_errno(r, "could not initialize labelling: %m");
1804 goto exit;
1805 }
1806
1807 r = mkdir_errno_wrapper("/run/udev", 0755);
1808 if (r < 0 && r != -EEXIST) {
1809 log_error_errno(r, "could not create /run/udev: %m");
1810 goto exit;
1811 }
1812
1813 dev_setup(NULL, UID_INVALID, GID_INVALID);
1814
1815 if (getppid() == 1) {
1816 /* get our own cgroup, we regularly kill everything udev has left behind
1817 we only do this on systemd systems, and only if we are directly spawned
1818 by PID1. otherwise we are not guaranteed to have a dedicated cgroup */
1819 r = cg_pid_get_path(SYSTEMD_CGROUP_CONTROLLER, 0, &cgroup);
1820 if (r < 0) {
1821 if (IN_SET(r, -ENOENT, -ENOMEDIUM))
1822 log_debug_errno(r, "did not find dedicated cgroup: %m");
1823 else
1824 log_warning_errno(r, "failed to get cgroup: %m");
1825 }
1826 }
1827
1828 r = listen_fds(&fd_ctrl, &fd_uevent);
1829 if (r < 0) {
1830 r = log_error_errno(r, "could not listen on fds: %m");
1831 goto exit;
1832 }
1833
1834 if (arg_daemonize) {
1835 pid_t pid;
1836
1837 log_info("starting version " PACKAGE_VERSION);
1838
1839 /* connect /dev/null to stdin, stdout, stderr */
1840 if (log_get_max_level() < LOG_DEBUG) {
1841 r = make_null_stdio();
1842 if (r < 0)
1843 log_warning_errno(r, "Failed to redirect standard streams to /dev/null: %m");
1844 }
1845
1846 pid = fork();
1847 switch (pid) {
1848 case 0:
1849 break;
1850 case -1:
1851 r = log_error_errno(errno, "fork of daemon failed: %m");
1852 goto exit;
1853 default:
1854 mac_selinux_finish();
1855 log_close();
1856 _exit(EXIT_SUCCESS);
1857 }
1858
1859 setsid();
1860
1861 r = set_oom_score_adjust(-1000);
1862 if (r < 0)
1863 log_debug_errno(r, "Failed to adjust OOM score, ignoring: %m");
1864 }
1865
1866 r = run(fd_ctrl, fd_uevent, cgroup);
1867
1868 exit:
1869 mac_selinux_finish();
1870 log_close();
1871 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1872 }
Unnamed repository; edit this file 'description' to name the repository.