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