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