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