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