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