]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/udev/udevd.c
projects / thirdparty / systemd.git / blob
? search:


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