]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/manager.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
core: use automatic cleanup in two functions
[thirdparty/systemd.git] / src / core / manager.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <assert.h>
23 #include <errno.h>
24 #include <string.h>
25 #include <signal.h>
26 #include <sys/wait.h>
27 #include <unistd.h>
28 #include <sys/poll.h>
29 #include <sys/reboot.h>
30 #include <sys/ioctl.h>
31 #include <linux/kd.h>
32 #include <termios.h>
33 #include <fcntl.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <dirent.h>
37 #include <sys/timerfd.h>
38
39 #ifdef HAVE_AUDIT
40 #include <libaudit.h>
41 #endif
42
43 #include "sd-daemon.h"
44 #include "sd-id128.h"
45 #include "sd-messages.h"
46
47 #include "manager.h"
48 #include "transaction.h"
49 #include "hashmap.h"
50 #include "macro.h"
51 #include "strv.h"
52 #include "log.h"
53 #include "util.h"
54 #include "mkdir.h"
55 #include "ratelimit.h"
56 #include "locale-setup.h"
57 #include "mount-setup.h"
58 #include "unit-name.h"
59 #include "missing.h"
60 #include "path-lookup.h"
61 #include "special.h"
62 #include "exit-status.h"
63 #include "virt.h"
64 #include "watchdog.h"
65 #include "cgroup-util.h"
66 #include "path-util.h"
67 #include "audit-fd.h"
68 #include "boot-timestamps.h"
69 #include "env-util.h"
70 #include "bus-errors.h"
71 #include "bus-error.h"
72 #include "bus-util.h"
73 #include "dbus.h"
74 #include "dbus-unit.h"
75 #include "dbus-job.h"
76 #include "dbus-manager.h"
77 #include "bus-kernel.h"
78
79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
81
82 /* Initial delay and the interval for printing status messages about running jobs */
83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
86
87 /* Where clients shall send notification messages to */
88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
89
90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
91
92 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
95 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
96 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
97 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
98
99 static int manager_watch_jobs_in_progress(Manager *m) {
100 usec_t next;
101
102 assert(m);
103
104 if (m->jobs_in_progress_event_source)
105 return 0;
106
107 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
108 return sd_event_add_monotonic(m->event, next, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
109 }
110
111 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
112
113 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
114 char *p = buffer;
115
116 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
117 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
118
119 if (pos > 1) {
120 if (pos > 2)
121 p = mempset(p, ' ', pos-2);
122 p = stpcpy(p, ANSI_RED_ON);
123 *p++ = '*';
124 }
125
126 if (pos > 0 && pos <= width) {
127 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
128 *p++ = '*';
129 }
130
131 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
132
133 if (pos < width) {
134 p = stpcpy(p, ANSI_RED_ON);
135 *p++ = '*';
136 if (pos < width-1)
137 p = mempset(p, ' ', width-1-pos);
138 strcpy(p, ANSI_HIGHLIGHT_OFF);
139 }
140 }
141
142 void manager_flip_auto_status(Manager *m, bool enable) {
143 if (enable) {
144 if (m->show_status == SHOW_STATUS_AUTO)
145 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
146 } else {
147 if (m->show_status == SHOW_STATUS_TEMPORARY)
148 manager_set_show_status(m, SHOW_STATUS_AUTO);
149 }
150 }
151
152 static void manager_print_jobs_in_progress(Manager *m) {
153 _cleanup_free_ char *job_of_n = NULL;
154 Iterator i;
155 Job *j;
156 unsigned counter = 0, print_nr;
157 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
158 unsigned cylon_pos;
159 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
160 uint64_t x;
161
162 assert(m);
163
164 manager_flip_auto_status(m, true);
165
166 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
167
168 HASHMAP_FOREACH(j, m->jobs, i)
169 if (j->state == JOB_RUNNING && counter++ == print_nr)
170 break;
171
172 /* m->n_running_jobs must be consistent with the contents of m->jobs,
173 * so the above loop must have succeeded in finding j. */
174 assert(counter == print_nr + 1);
175 assert(j);
176
177 cylon_pos = m->jobs_in_progress_iteration % 14;
178 if (cylon_pos >= 8)
179 cylon_pos = 14 - cylon_pos;
180 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
181
182 m->jobs_in_progress_iteration++;
183
184 if (m->n_running_jobs > 1)
185 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
186 job_of_n = NULL;
187
188 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
189 if (job_get_timeout(j, &x) > 0)
190 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
191
192 manager_status_printf(m, true, cylon,
193 "%sA %s job is running for %s (%s / %s)",
194 strempty(job_of_n),
195 job_type_to_string(j->type),
196 unit_description(j->unit),
197 time, limit);
198
199 }
200
201 static int manager_watch_idle_pipe(Manager *m) {
202 int r;
203
204 assert(m);
205
206 if (m->idle_pipe_event_source)
207 return 0;
208
209 if (m->idle_pipe[2] < 0)
210 return 0;
211
212 r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
213 if (r < 0) {
214 log_error("Failed to watch idle pipe: %s", strerror(-r));
215 return r;
216 }
217
218 return 0;
219 }
220
221 static void manager_close_idle_pipe(Manager *m) {
222 assert(m);
223
224 close_pipe(m->idle_pipe);
225 close_pipe(m->idle_pipe + 2);
226 }
227
228 static int manager_setup_time_change(Manager *m) {
229 int r;
230
231 /* We only care for the cancellation event, hence we set the
232 * timeout to the latest possible value. */
233 struct itimerspec its = {
234 .it_value.tv_sec = TIME_T_MAX,
235 };
236
237 assert(m);
238 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
239
240 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
241 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
242
243 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
244 if (m->time_change_fd < 0) {
245 log_error("Failed to create timerfd: %m");
246 return -errno;
247 }
248
249 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
250 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
251 close_nointr_nofail(m->time_change_fd);
252 m->time_change_fd = -1;
253 return 0;
254 }
255
256 r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
257 if (r < 0) {
258 log_error("Failed to create time change event source: %s", strerror(-r));
259 return r;
260 }
261
262 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
263
264 return 0;
265 }
266
267 static int enable_special_signals(Manager *m) {
268 _cleanup_close_ int fd = -1;
269
270 assert(m);
271
272 /* Enable that we get SIGINT on control-alt-del. In containers
273 * this will fail with EPERM (older) or EINVAL (newer), so
274 * ignore that. */
275 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
276 log_warning("Failed to enable ctrl-alt-del handling: %m");
277
278 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
279 if (fd < 0) {
280 /* Support systems without virtual console */
281 if (fd != -ENOENT)
282 log_warning("Failed to open /dev/tty0: %m");
283 } else {
284 /* Enable that we get SIGWINCH on kbrequest */
285 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
286 log_warning("Failed to enable kbrequest handling: %m");
287 }
288
289 return 0;
290 }
291
292 static int manager_setup_signals(Manager *m) {
293 struct sigaction sa = {
294 .sa_handler = SIG_DFL,
295 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
296 };
297 sigset_t mask;
298 int r;
299
300 assert(m);
301
302 /* We are not interested in SIGSTOP and friends. */
303 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
304
305 assert_se(sigemptyset(&mask) == 0);
306
307 sigset_add_many(&mask,
308 SIGCHLD, /* Child died */
309 SIGTERM, /* Reexecute daemon */
310 SIGHUP, /* Reload configuration */
311 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
312 SIGUSR2, /* systemd: dump status */
313 SIGINT, /* Kernel sends us this on control-alt-del */
314 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
315 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
316 SIGRTMIN+0, /* systemd: start default.target */
317 SIGRTMIN+1, /* systemd: isolate rescue.target */
318 SIGRTMIN+2, /* systemd: isolate emergency.target */
319 SIGRTMIN+3, /* systemd: start halt.target */
320 SIGRTMIN+4, /* systemd: start poweroff.target */
321 SIGRTMIN+5, /* systemd: start reboot.target */
322 SIGRTMIN+6, /* systemd: start kexec.target */
323 SIGRTMIN+13, /* systemd: Immediate halt */
324 SIGRTMIN+14, /* systemd: Immediate poweroff */
325 SIGRTMIN+15, /* systemd: Immediate reboot */
326 SIGRTMIN+16, /* systemd: Immediate kexec */
327 SIGRTMIN+20, /* systemd: enable status messages */
328 SIGRTMIN+21, /* systemd: disable status messages */
329 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
330 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
331 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
332 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
333 SIGRTMIN+27, /* systemd: set log target to console */
334 SIGRTMIN+28, /* systemd: set log target to kmsg */
335 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
336 -1);
337 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
338
339 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
340 if (m->signal_fd < 0)
341 return -errno;
342
343 r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
344 if (r < 0)
345 return r;
346
347 /* Process signals a bit earlier than the rest of things, but
348 * later that notify_fd processing, so that the notify
349 * processing can still figure out to which process/service a
350 * message belongs, before we reap the process. */
351 r = sd_event_source_set_priority(m->signal_event_source, -5);
352 if (r < 0)
353 return r;
354
355 if (m->running_as == SYSTEMD_SYSTEM)
356 return enable_special_signals(m);
357
358 return 0;
359 }
360
361 static void manager_clean_environment(Manager *m) {
362 assert(m);
363
364 /* Let's remove some environment variables that we
365 * need ourselves to communicate with our clients */
366 strv_env_unset_many(
367 m->environment,
368 "NOTIFY_SOCKET",
369 "MAINPID",
370 "MANAGERPID",
371 "LISTEN_PID",
372 "LISTEN_FDS",
373 "WATCHDOG_PID",
374 "WATCHDOG_USEC",
375 NULL);
376 }
377
378 static int manager_default_environment(Manager *m) {
379 assert(m);
380
381 if (m->running_as == SYSTEMD_SYSTEM) {
382 /* The system manager always starts with a clean
383 * environment for its children. It does not import
384 * the kernel or the parents exported variables.
385 *
386 * The initial passed environ is untouched to keep
387 * /proc/self/environ valid; it is used for tagging
388 * the init process inside containers. */
389 m->environment = strv_new("PATH=" DEFAULT_PATH,
390 NULL);
391
392 /* Import locale variables LC_*= from configuration */
393 locale_setup(&m->environment);
394 } else {
395 /* The user manager passes its own environment
396 * along to its children. */
397 m->environment = strv_copy(environ);
398 }
399
400 if (!m->environment)
401 return -ENOMEM;
402
403 manager_clean_environment(m);
404 strv_sort(m->environment);
405
406 return 0;
407 }
408
409 int manager_new(SystemdRunningAs running_as, Manager **_m) {
410 Manager *m;
411 int r;
412
413 assert(_m);
414 assert(running_as >= 0);
415 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
416
417 m = new0(Manager, 1);
418 if (!m)
419 return -ENOMEM;
420
421 #ifdef ENABLE_EFI
422 if (detect_container(NULL) <= 0)
423 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
424 #endif
425
426 m->running_as = running_as;
427 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
428
429 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
430
431 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = -1;
432 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
433
434 r = manager_default_environment(m);
435 if (r < 0)
436 goto fail;
437
438 r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
439 if (r < 0)
440 goto fail;
441
442 r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
443 if (r < 0)
444 goto fail;
445
446 r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
447 if (r < 0)
448 goto fail;
449
450 r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
451 if (r < 0)
452 goto fail;
453
454 r = sd_event_default(&m->event);
455 if (r < 0)
456 goto fail;
457
458 r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
459 if (r < 0)
460 goto fail;
461
462 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
463 if (r < 0)
464 goto fail;
465
466 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
467 if (r < 0)
468 goto fail;
469
470 r = manager_setup_signals(m);
471 if (r < 0)
472 goto fail;
473
474 r = manager_setup_cgroup(m);
475 if (r < 0)
476 goto fail;
477
478 r = manager_setup_time_change(m);
479 if (r < 0)
480 goto fail;
481
482 m->udev = udev_new();
483 if (!m->udev) {
484 r = -ENOMEM;
485 goto fail;
486 }
487
488 /* Note that we set up neither kdbus, nor the notify fd
489 * here. We do that after deserialization, since they might
490 * have gotten serialized across the reexec. */
491
492 m->taint_usr = dir_is_empty("/usr") > 0;
493
494 *_m = m;
495 return 0;
496
497 fail:
498 manager_free(m);
499 return r;
500 }
501
502 static int manager_setup_notify(Manager *m) {
503 union {
504 struct sockaddr sa;
505 struct sockaddr_un un;
506 } sa = {
507 .sa.sa_family = AF_UNIX,
508 };
509 int one = 1, r;
510
511 if (m->notify_fd < 0) {
512 _cleanup_close_ int fd = -1;
513
514 /* First free all secondary fields */
515 free(m->notify_socket);
516 m->notify_socket = NULL;
517 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
518
519 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
520 if (fd < 0) {
521 log_error("Failed to allocate notification socket: %m");
522 return -errno;
523 }
524
525 if (getpid() != 1 || detect_container(NULL) > 0)
526 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
527 else
528 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
529 sa.un.sun_path[0] = 0;
530
531 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
532 if (r < 0) {
533 log_error("bind() failed: %m");
534 return -errno;
535 }
536
537 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
538 if (r < 0) {
539 log_error("SO_PASSCRED failed: %m");
540 return -errno;
541 }
542
543 sa.un.sun_path[0] = '@';
544 m->notify_socket = strdup(sa.un.sun_path);
545 if (!m->notify_socket)
546 return log_oom();
547
548 m->notify_fd = fd;
549 fd = -1;
550
551 log_debug("Using notification socket %s", m->notify_socket);
552 }
553
554 if (!m->notify_event_source) {
555 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
556 if (r < 0) {
557 log_error("Failed to allocate notify event source: %s", strerror(-r));
558 return -errno;
559 }
560
561 /* Process signals a bit earlier than SIGCHLD, so that we can
562 * still identify to which service an exit message belongs */
563 r = sd_event_source_set_priority(m->notify_event_source, -7);
564 if (r < 0) {
565 log_error("Failed to set priority of notify event source: %s", strerror(-r));
566 return r;
567 }
568 }
569
570 return 0;
571 }
572
573 static int manager_setup_kdbus(Manager *m) {
574 #ifdef ENABLE_KDBUS
575 _cleanup_free_ char *p = NULL;
576 #endif
577
578 #ifdef ENABLE_KDBUS
579 assert(m);
580
581 if (m->kdbus_fd >= 0)
582 return 0;
583
584 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
585 if (m->kdbus_fd < 0) {
586 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
587 return m->kdbus_fd;
588 }
589
590 log_debug("Successfully set up kdbus on %s", p);
591
592 /* Create the namespace directory here, so that the contents
593 * of that directory is not visible to non-root users. This is
594 * necessary to ensure that users cannot get access to busses
595 * of virtualized users when no UID namespacing is used. */
596 if (m->running_as == SYSTEMD_SYSTEM)
597 mkdir_p_label("/dev/kdbus/domain", 0700);
598 #endif
599
600 return 0;
601 }
602
603 static int manager_connect_bus(Manager *m, bool reexecuting) {
604 bool try_bus_connect;
605
606 assert(m);
607
608 try_bus_connect =
609 m->kdbus_fd >= 0 ||
610 reexecuting ||
611 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
612
613 /* Try to connect to the busses, if possible. */
614 return bus_init(m, try_bus_connect);
615 }
616
617 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
618 Unit *u;
619 unsigned n = 0;
620
621 assert(m);
622
623 while ((u = m->cleanup_queue)) {
624 assert(u->in_cleanup_queue);
625
626 unit_free(u);
627 n++;
628 }
629
630 return n;
631 }
632
633 enum {
634 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
635 GC_OFFSET_UNSURE, /* No clue */
636 GC_OFFSET_GOOD, /* We still need this unit */
637 GC_OFFSET_BAD, /* We don't need this unit anymore */
638 _GC_OFFSET_MAX
639 };
640
641 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
642 Iterator i;
643 Unit *other;
644 bool is_bad;
645
646 assert(u);
647
648 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
649 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
650 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
651 return;
652
653 if (u->in_cleanup_queue)
654 goto bad;
655
656 if (unit_check_gc(u))
657 goto good;
658
659 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
660
661 is_bad = true;
662
663 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
664 unit_gc_sweep(other, gc_marker);
665
666 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
667 goto good;
668
669 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
670 is_bad = false;
671 }
672
673 if (is_bad)
674 goto bad;
675
676 /* We were unable to find anything out about this entry, so
677 * let's investigate it later */
678 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
679 unit_add_to_gc_queue(u);
680 return;
681
682 bad:
683 /* We definitely know that this one is not useful anymore, so
684 * let's mark it for deletion */
685 u->gc_marker = gc_marker + GC_OFFSET_BAD;
686 unit_add_to_cleanup_queue(u);
687 return;
688
689 good:
690 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
691 }
692
693 static unsigned manager_dispatch_gc_queue(Manager *m) {
694 Unit *u;
695 unsigned n = 0;
696 unsigned gc_marker;
697
698 assert(m);
699
700 /* log_debug("Running GC..."); */
701
702 m->gc_marker += _GC_OFFSET_MAX;
703 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
704 m->gc_marker = 1;
705
706 gc_marker = m->gc_marker;
707
708 while ((u = m->gc_queue)) {
709 assert(u->in_gc_queue);
710
711 unit_gc_sweep(u, gc_marker);
712
713 LIST_REMOVE(gc_queue, m->gc_queue, u);
714 u->in_gc_queue = false;
715
716 n++;
717
718 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
719 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
720 log_debug_unit(u->id, "Collecting %s", u->id);
721 u->gc_marker = gc_marker + GC_OFFSET_BAD;
722 unit_add_to_cleanup_queue(u);
723 }
724 }
725
726 m->n_in_gc_queue = 0;
727
728 return n;
729 }
730
731 static void manager_clear_jobs_and_units(Manager *m) {
732 Unit *u;
733
734 assert(m);
735
736 while ((u = hashmap_first(m->units)))
737 unit_free(u);
738
739 manager_dispatch_cleanup_queue(m);
740
741 assert(!m->load_queue);
742 assert(!m->run_queue);
743 assert(!m->dbus_unit_queue);
744 assert(!m->dbus_job_queue);
745 assert(!m->cleanup_queue);
746 assert(!m->gc_queue);
747
748 assert(hashmap_isempty(m->jobs));
749 assert(hashmap_isempty(m->units));
750
751 m->n_on_console = 0;
752 m->n_running_jobs = 0;
753 }
754
755 void manager_free(Manager *m) {
756 UnitType c;
757 int i;
758
759 assert(m);
760
761 manager_clear_jobs_and_units(m);
762
763 for (c = 0; c < _UNIT_TYPE_MAX; c++)
764 if (unit_vtable[c]->shutdown)
765 unit_vtable[c]->shutdown(m);
766
767 /* If we reexecute ourselves, we keep the root cgroup
768 * around */
769 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
770
771 manager_undo_generators(m);
772
773 bus_done(m);
774
775 hashmap_free(m->units);
776 hashmap_free(m->jobs);
777 hashmap_free(m->watch_pids1);
778 hashmap_free(m->watch_pids2);
779 hashmap_free(m->watch_bus);
780
781 sd_event_source_unref(m->signal_event_source);
782 sd_event_source_unref(m->notify_event_source);
783 sd_event_source_unref(m->time_change_event_source);
784 sd_event_source_unref(m->jobs_in_progress_event_source);
785 sd_event_source_unref(m->idle_pipe_event_source);
786 sd_event_source_unref(m->run_queue_event_source);
787
788 if (m->signal_fd >= 0)
789 close_nointr_nofail(m->signal_fd);
790 if (m->notify_fd >= 0)
791 close_nointr_nofail(m->notify_fd);
792 if (m->time_change_fd >= 0)
793 close_nointr_nofail(m->time_change_fd);
794 if (m->kdbus_fd >= 0)
795 close_nointr_nofail(m->kdbus_fd);
796
797 manager_close_idle_pipe(m);
798
799 udev_unref(m->udev);
800 sd_event_unref(m->event);
801
802 free(m->notify_socket);
803
804 lookup_paths_free(&m->lookup_paths);
805 strv_free(m->environment);
806
807 hashmap_free(m->cgroup_unit);
808 set_free_free(m->unit_path_cache);
809
810 free(m->switch_root);
811 free(m->switch_root_init);
812
813 for (i = 0; i < RLIMIT_NLIMITS; i++)
814 free(m->rlimit[i]);
815
816 assert(hashmap_isempty(m->units_requiring_mounts_for));
817 hashmap_free(m->units_requiring_mounts_for);
818
819 free(m);
820 }
821
822 int manager_enumerate(Manager *m) {
823 int r = 0, q;
824 UnitType c;
825
826 assert(m);
827
828 /* Let's ask every type to load all units from disk/kernel
829 * that it might know */
830 for (c = 0; c < _UNIT_TYPE_MAX; c++)
831 if (unit_vtable[c]->enumerate) {
832 q = unit_vtable[c]->enumerate(m);
833 if (q < 0)
834 r = q;
835 }
836
837 manager_dispatch_load_queue(m);
838 return r;
839 }
840
841 static int manager_coldplug(Manager *m) {
842 int r = 0, q;
843 Iterator i;
844 Unit *u;
845 char *k;
846
847 assert(m);
848
849 /* Then, let's set up their initial state. */
850 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
851
852 /* ignore aliases */
853 if (u->id != k)
854 continue;
855
856 if ((q = unit_coldplug(u)) < 0)
857 r = q;
858 }
859
860 return r;
861 }
862
863 static void manager_build_unit_path_cache(Manager *m) {
864 char **i;
865 _cleanup_free_ DIR *d = NULL;
866 int r;
867
868 assert(m);
869
870 set_free_free(m->unit_path_cache);
871
872 m->unit_path_cache = set_new(string_hash_func, string_compare_func);
873 if (!m->unit_path_cache) {
874 log_error("Failed to allocate unit path cache.");
875 return;
876 }
877
878 /* This simply builds a list of files we know exist, so that
879 * we don't always have to go to disk */
880
881 STRV_FOREACH(i, m->lookup_paths.unit_path) {
882 struct dirent *de;
883
884 d = opendir(*i);
885 if (!d) {
886 if (errno != ENOENT)
887 log_error("Failed to open directory %s: %m", *i);
888 continue;
889 }
890
891 while ((de = readdir(d))) {
892 char *p;
893
894 if (ignore_file(de->d_name))
895 continue;
896
897 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
898 if (!p) {
899 r = -ENOMEM;
900 goto fail;
901 }
902
903 r = set_consume(m->unit_path_cache, p);
904 if (r < 0)
905 goto fail;
906 }
907
908 closedir(d);
909 d = NULL;
910 }
911
912 return;
913
914 fail:
915 log_error("Failed to build unit path cache: %s", strerror(-r));
916
917 set_free_free(m->unit_path_cache);
918 m->unit_path_cache = NULL;
919 }
920
921
922 static int manager_distribute_fds(Manager *m, FDSet *fds) {
923 Unit *u;
924 Iterator i;
925 int r;
926
927 assert(m);
928
929 HASHMAP_FOREACH(u, m->units, i) {
930
931 if (fdset_size(fds) <= 0)
932 break;
933
934 if (UNIT_VTABLE(u)->distribute_fds) {
935 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
936 if (r < 0)
937 return r;
938 }
939 }
940
941 return 0;
942 }
943
944 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
945 int r, q;
946
947 assert(m);
948
949 dual_timestamp_get(&m->generators_start_timestamp);
950 manager_run_generators(m);
951 dual_timestamp_get(&m->generators_finish_timestamp);
952
953 r = lookup_paths_init(
954 &m->lookup_paths, m->running_as, true,
955 m->generator_unit_path,
956 m->generator_unit_path_early,
957 m->generator_unit_path_late);
958 if (r < 0)
959 return r;
960
961 manager_build_unit_path_cache(m);
962
963 /* If we will deserialize make sure that during enumeration
964 * this is already known, so we increase the counter here
965 * already */
966 if (serialization)
967 m->n_reloading ++;
968
969 /* First, enumerate what we can from all config files */
970 dual_timestamp_get(&m->units_load_start_timestamp);
971 r = manager_enumerate(m);
972 dual_timestamp_get(&m->units_load_finish_timestamp);
973
974 /* Second, deserialize if there is something to deserialize */
975 if (serialization) {
976 q = manager_deserialize(m, serialization, fds);
977 if (q < 0)
978 r = q;
979 }
980
981 /* Any fds left? Find some unit which wants them. This is
982 * useful to allow container managers to pass some file
983 * descriptors to us pre-initialized. This enables
984 * socket-based activation of entire containers. */
985 if (fdset_size(fds) > 0) {
986 q = manager_distribute_fds(m, fds);
987 if (q < 0)
988 r = q;
989 }
990
991 /* We might have deserialized the notify fd, but if we didn't
992 * then let's create the bus now */
993 manager_setup_notify(m);
994
995 /* We might have deserialized the kdbus control fd, but if we
996 * didn't, then let's create the bus now. */
997 manager_setup_kdbus(m);
998 manager_connect_bus(m, !!serialization);
999
1000 /* Third, fire things up! */
1001 q = manager_coldplug(m);
1002 if (q < 0)
1003 r = q;
1004
1005 if (serialization) {
1006 assert(m->n_reloading > 0);
1007 m->n_reloading --;
1008
1009 /* Let's wait for the UnitNew/JobNew messages being
1010 * sent, before we notify that the reload is
1011 * finished */
1012 m->send_reloading_done = true;
1013 }
1014
1015 return r;
1016 }
1017
1018 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1019 int r;
1020 Transaction *tr;
1021
1022 assert(m);
1023 assert(type < _JOB_TYPE_MAX);
1024 assert(unit);
1025 assert(mode < _JOB_MODE_MAX);
1026
1027 if (mode == JOB_ISOLATE && type != JOB_START) {
1028 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1029 return -EINVAL;
1030 }
1031
1032 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1033 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1034 return -EPERM;
1035 }
1036
1037 log_debug_unit(unit->id,
1038 "Trying to enqueue job %s/%s/%s", unit->id,
1039 job_type_to_string(type), job_mode_to_string(mode));
1040
1041 job_type_collapse(&type, unit);
1042
1043 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1044 if (!tr)
1045 return -ENOMEM;
1046
1047 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1048 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1049 mode == JOB_IGNORE_DEPENDENCIES, e);
1050 if (r < 0)
1051 goto tr_abort;
1052
1053 if (mode == JOB_ISOLATE) {
1054 r = transaction_add_isolate_jobs(tr, m);
1055 if (r < 0)
1056 goto tr_abort;
1057 }
1058
1059 r = transaction_activate(tr, m, mode, e);
1060 if (r < 0)
1061 goto tr_abort;
1062
1063 log_debug_unit(unit->id,
1064 "Enqueued job %s/%s as %u", unit->id,
1065 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1066
1067 if (_ret)
1068 *_ret = tr->anchor_job;
1069
1070 transaction_free(tr);
1071 return 0;
1072
1073 tr_abort:
1074 transaction_abort(tr);
1075 transaction_free(tr);
1076 return r;
1077 }
1078
1079 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1080 Unit *unit;
1081 int r;
1082
1083 assert(m);
1084 assert(type < _JOB_TYPE_MAX);
1085 assert(name);
1086 assert(mode < _JOB_MODE_MAX);
1087
1088 r = manager_load_unit(m, name, NULL, NULL, &unit);
1089 if (r < 0)
1090 return r;
1091
1092 return manager_add_job(m, type, unit, mode, override, e, _ret);
1093 }
1094
1095 Job *manager_get_job(Manager *m, uint32_t id) {
1096 assert(m);
1097
1098 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1099 }
1100
1101 Unit *manager_get_unit(Manager *m, const char *name) {
1102 assert(m);
1103 assert(name);
1104
1105 return hashmap_get(m->units, name);
1106 }
1107
1108 unsigned manager_dispatch_load_queue(Manager *m) {
1109 Unit *u;
1110 unsigned n = 0;
1111
1112 assert(m);
1113
1114 /* Make sure we are not run recursively */
1115 if (m->dispatching_load_queue)
1116 return 0;
1117
1118 m->dispatching_load_queue = true;
1119
1120 /* Dispatches the load queue. Takes a unit from the queue and
1121 * tries to load its data until the queue is empty */
1122
1123 while ((u = m->load_queue)) {
1124 assert(u->in_load_queue);
1125
1126 unit_load(u);
1127 n++;
1128 }
1129
1130 m->dispatching_load_queue = false;
1131 return n;
1132 }
1133
1134 int manager_load_unit_prepare(
1135 Manager *m,
1136 const char *name,
1137 const char *path,
1138 sd_bus_error *e,
1139 Unit **_ret) {
1140
1141 Unit *ret;
1142 UnitType t;
1143 int r;
1144
1145 assert(m);
1146 assert(name || path);
1147
1148 /* This will prepare the unit for loading, but not actually
1149 * load anything from disk. */
1150
1151 if (path && !is_path(path))
1152 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1153
1154 if (!name)
1155 name = basename(path);
1156
1157 t = unit_name_to_type(name);
1158
1159 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1160 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1161
1162 ret = manager_get_unit(m, name);
1163 if (ret) {
1164 *_ret = ret;
1165 return 1;
1166 }
1167
1168 ret = unit_new(m, unit_vtable[t]->object_size);
1169 if (!ret)
1170 return -ENOMEM;
1171
1172 if (path) {
1173 ret->fragment_path = strdup(path);
1174 if (!ret->fragment_path) {
1175 unit_free(ret);
1176 return -ENOMEM;
1177 }
1178 }
1179
1180 r = unit_add_name(ret, name);
1181 if (r < 0) {
1182 unit_free(ret);
1183 return r;
1184 }
1185
1186 unit_add_to_load_queue(ret);
1187 unit_add_to_dbus_queue(ret);
1188 unit_add_to_gc_queue(ret);
1189
1190 if (_ret)
1191 *_ret = ret;
1192
1193 return 0;
1194 }
1195
1196 int manager_load_unit(
1197 Manager *m,
1198 const char *name,
1199 const char *path,
1200 sd_bus_error *e,
1201 Unit **_ret) {
1202
1203 int r;
1204
1205 assert(m);
1206
1207 /* This will load the service information files, but not actually
1208 * start any services or anything. */
1209
1210 r = manager_load_unit_prepare(m, name, path, e, _ret);
1211 if (r != 0)
1212 return r;
1213
1214 manager_dispatch_load_queue(m);
1215
1216 if (_ret)
1217 *_ret = unit_follow_merge(*_ret);
1218
1219 return 0;
1220 }
1221
1222 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1223 Iterator i;
1224 Job *j;
1225
1226 assert(s);
1227 assert(f);
1228
1229 HASHMAP_FOREACH(j, s->jobs, i)
1230 job_dump(j, f, prefix);
1231 }
1232
1233 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1234 Iterator i;
1235 Unit *u;
1236 const char *t;
1237
1238 assert(s);
1239 assert(f);
1240
1241 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1242 if (u->id == t)
1243 unit_dump(u, f, prefix);
1244 }
1245
1246 void manager_clear_jobs(Manager *m) {
1247 Job *j;
1248
1249 assert(m);
1250
1251 while ((j = hashmap_first(m->jobs)))
1252 /* No need to recurse. We're cancelling all jobs. */
1253 job_finish_and_invalidate(j, JOB_CANCELED, false);
1254 }
1255
1256 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1257 Manager *m = userdata;
1258 Job *j;
1259
1260 assert(source);
1261 assert(m);
1262
1263 while ((j = m->run_queue)) {
1264 assert(j->installed);
1265 assert(j->in_run_queue);
1266
1267 job_run_and_invalidate(j);
1268 }
1269
1270 if (m->n_running_jobs > 0)
1271 manager_watch_jobs_in_progress(m);
1272
1273 if (m->n_on_console > 0)
1274 manager_watch_idle_pipe(m);
1275
1276 return 1;
1277 }
1278
1279 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1280 Job *j;
1281 Unit *u;
1282 unsigned n = 0;
1283
1284 assert(m);
1285
1286 if (m->dispatching_dbus_queue)
1287 return 0;
1288
1289 m->dispatching_dbus_queue = true;
1290
1291 while ((u = m->dbus_unit_queue)) {
1292 assert(u->in_dbus_queue);
1293
1294 bus_unit_send_change_signal(u);
1295 n++;
1296 }
1297
1298 while ((j = m->dbus_job_queue)) {
1299 assert(j->in_dbus_queue);
1300
1301 bus_job_send_change_signal(j);
1302 n++;
1303 }
1304
1305 m->dispatching_dbus_queue = false;
1306
1307 if (m->send_reloading_done) {
1308 m->send_reloading_done = false;
1309
1310 bus_manager_send_reloading(m, false);
1311 }
1312
1313 if (m->queued_message)
1314 bus_send_queued_message(m);
1315
1316 return n;
1317 }
1318
1319 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1320 _cleanup_strv_free_ char **tags = NULL;
1321
1322 assert(m);
1323 assert(u);
1324 assert(buf);
1325 assert(n > 0);
1326
1327 tags = strv_split(buf, "\n\r");
1328 if (!tags) {
1329 log_oom();
1330 return;
1331 }
1332
1333 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1334
1335 if (UNIT_VTABLE(u)->notify_message)
1336 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1337 }
1338
1339 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1340 Manager *m = userdata;
1341 ssize_t n;
1342
1343 assert(m);
1344 assert(m->notify_fd == fd);
1345
1346 if (revents != EPOLLIN) {
1347 log_warning("Got unexpected poll event for notify fd.");
1348 return 0;
1349 }
1350
1351 for (;;) {
1352 char buf[4096];
1353 struct iovec iovec = {
1354 .iov_base = buf,
1355 .iov_len = sizeof(buf)-1,
1356 };
1357 bool found = false;
1358
1359 union {
1360 struct cmsghdr cmsghdr;
1361 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1362 } control = {};
1363
1364 struct msghdr msghdr = {
1365 .msg_iov = &iovec,
1366 .msg_iovlen = 1,
1367 .msg_control = &control,
1368 .msg_controllen = sizeof(control),
1369 };
1370 struct ucred *ucred;
1371 Unit *u;
1372
1373 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1374 if (n <= 0) {
1375 if (n == 0)
1376 return -EIO;
1377
1378 if (errno == EAGAIN || errno == EINTR)
1379 break;
1380
1381 return -errno;
1382 }
1383
1384 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1385 control.cmsghdr.cmsg_level != SOL_SOCKET ||
1386 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1387 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1388 log_warning("Received notify message without credentials. Ignoring.");
1389 continue;
1390 }
1391
1392 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1393
1394 assert((size_t) n < sizeof(buf));
1395 buf[n] = 0;
1396
1397 u = manager_get_unit_by_pid(m, ucred->pid);
1398 if (u) {
1399 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1400 found = true;
1401 }
1402
1403 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1404 if (u) {
1405 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1406 found = true;
1407 }
1408
1409 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1410 if (u) {
1411 manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1412 found = true;
1413 }
1414
1415 if (!found)
1416 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1417 }
1418
1419 return 0;
1420 }
1421
1422 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1423 assert(m);
1424 assert(u);
1425 assert(si);
1426
1427 log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1428
1429 unit_unwatch_pid(u, si->si_pid);
1430 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1431 }
1432
1433 static int manager_dispatch_sigchld(Manager *m) {
1434 assert(m);
1435
1436 for (;;) {
1437 siginfo_t si = {};
1438
1439 /* First we call waitd() for a PID and do not reap the
1440 * zombie. That way we can still access /proc/$PID for
1441 * it while it is a zombie. */
1442 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1443
1444 if (errno == ECHILD)
1445 break;
1446
1447 if (errno == EINTR)
1448 continue;
1449
1450 return -errno;
1451 }
1452
1453 if (si.si_pid <= 0)
1454 break;
1455
1456 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1457 _cleanup_free_ char *name = NULL;
1458 Unit *u;
1459
1460 get_process_comm(si.si_pid, &name);
1461
1462 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1463 si.si_pid, strna(name),
1464 sigchld_code_to_string(si.si_code),
1465 si.si_status,
1466 strna(si.si_code == CLD_EXITED
1467 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1468 : signal_to_string(si.si_status)));
1469
1470 /* And now figure out the unit this belongs
1471 * to, it might be multiple... */
1472 u = manager_get_unit_by_pid(m, si.si_pid);
1473 if (u)
1474 invoke_sigchld_event(m, u, &si);
1475 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1476 if (u)
1477 invoke_sigchld_event(m, u, &si);
1478 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1479 if (u)
1480 invoke_sigchld_event(m, u, &si);
1481 }
1482
1483 /* And now, we actually reap the zombie. */
1484 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1485 if (errno == EINTR)
1486 continue;
1487
1488 return -errno;
1489 }
1490 }
1491
1492 return 0;
1493 }
1494
1495 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1496 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1497 int r;
1498
1499 log_debug_unit(name, "Activating special unit %s", name);
1500
1501 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1502 if (r < 0)
1503 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1504
1505 return r;
1506 }
1507
1508 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1509 Manager *m = userdata;
1510 ssize_t n;
1511 struct signalfd_siginfo sfsi;
1512 bool sigchld = false;
1513
1514 assert(m);
1515 assert(m->signal_fd == fd);
1516
1517 if (revents != EPOLLIN) {
1518 log_warning("Got unexpected events from signal file descriptor.");
1519 return 0;
1520 }
1521
1522 for (;;) {
1523 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1524 if (n != sizeof(sfsi)) {
1525
1526 if (n >= 0)
1527 return -EIO;
1528
1529 if (errno == EINTR || errno == EAGAIN)
1530 break;
1531
1532 return -errno;
1533 }
1534
1535 if (sfsi.ssi_pid > 0) {
1536 _cleanup_free_ char *p = NULL;
1537
1538 get_process_comm(sfsi.ssi_pid, &p);
1539
1540 log_full(sfsi.ssi_signo == SIGCHLD ||
1541 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1542 ? LOG_DEBUG : LOG_INFO,
1543 "Received SIG%s from PID "PID_FMT" (%s).",
1544 signal_to_string(sfsi.ssi_signo),
1545 sfsi.ssi_pid, strna(p));
1546 } else
1547 log_full(sfsi.ssi_signo == SIGCHLD ||
1548 (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1549 ? LOG_DEBUG : LOG_INFO,
1550 "Received SIG%s.",
1551 signal_to_string(sfsi.ssi_signo));
1552
1553 switch (sfsi.ssi_signo) {
1554
1555 case SIGCHLD:
1556 sigchld = true;
1557 break;
1558
1559 case SIGTERM:
1560 if (m->running_as == SYSTEMD_SYSTEM) {
1561 /* This is for compatibility with the
1562 * original sysvinit */
1563 m->exit_code = MANAGER_REEXECUTE;
1564 break;
1565 }
1566
1567 /* Fall through */
1568
1569 case SIGINT:
1570 if (m->running_as == SYSTEMD_SYSTEM) {
1571 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1572 break;
1573 }
1574
1575 /* Run the exit target if there is one, if not, just exit. */
1576 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1577 m->exit_code = MANAGER_EXIT;
1578 return 0;
1579 }
1580
1581 break;
1582
1583 case SIGWINCH:
1584 if (m->running_as == SYSTEMD_SYSTEM)
1585 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1586
1587 /* This is a nop on non-init */
1588 break;
1589
1590 case SIGPWR:
1591 if (m->running_as == SYSTEMD_SYSTEM)
1592 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1593
1594 /* This is a nop on non-init */
1595 break;
1596
1597 case SIGUSR1: {
1598 Unit *u;
1599
1600 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1601
1602 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1603 log_info("Trying to reconnect to bus...");
1604 bus_init(m, true);
1605 }
1606
1607 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1608 log_info("Loading D-Bus service...");
1609 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1610 }
1611
1612 break;
1613 }
1614
1615 case SIGUSR2: {
1616 _cleanup_free_ char *dump = NULL;
1617 _cleanup_fclose_ FILE *f = NULL;
1618 size_t size;
1619
1620 f = open_memstream(&dump, &size);
1621 if (!f) {
1622 log_warning("Failed to allocate memory stream.");
1623 break;
1624 }
1625
1626 manager_dump_units(m, f, "\t");
1627 manager_dump_jobs(m, f, "\t");
1628
1629 if (ferror(f)) {
1630 log_warning("Failed to write status stream");
1631 break;
1632 }
1633
1634 log_dump(LOG_INFO, dump);
1635 break;
1636 }
1637
1638 case SIGHUP:
1639 m->exit_code = MANAGER_RELOAD;
1640 break;
1641
1642 default: {
1643
1644 /* Starting SIGRTMIN+0 */
1645 static const char * const target_table[] = {
1646 [0] = SPECIAL_DEFAULT_TARGET,
1647 [1] = SPECIAL_RESCUE_TARGET,
1648 [2] = SPECIAL_EMERGENCY_TARGET,
1649 [3] = SPECIAL_HALT_TARGET,
1650 [4] = SPECIAL_POWEROFF_TARGET,
1651 [5] = SPECIAL_REBOOT_TARGET,
1652 [6] = SPECIAL_KEXEC_TARGET
1653 };
1654
1655 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1656 static const ManagerExitCode code_table[] = {
1657 [0] = MANAGER_HALT,
1658 [1] = MANAGER_POWEROFF,
1659 [2] = MANAGER_REBOOT,
1660 [3] = MANAGER_KEXEC
1661 };
1662
1663 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1664 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1665 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1666 manager_start_target(m, target_table[idx],
1667 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1668 break;
1669 }
1670
1671 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1672 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1673 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1674 break;
1675 }
1676
1677 switch (sfsi.ssi_signo - SIGRTMIN) {
1678
1679 case 20:
1680 log_debug("Enabling showing of status.");
1681 manager_set_show_status(m, SHOW_STATUS_YES);
1682 break;
1683
1684 case 21:
1685 log_debug("Disabling showing of status.");
1686 manager_set_show_status(m, SHOW_STATUS_NO);
1687 break;
1688
1689 case 22:
1690 log_set_max_level(LOG_DEBUG);
1691 log_notice("Setting log level to debug.");
1692 break;
1693
1694 case 23:
1695 log_set_max_level(LOG_INFO);
1696 log_notice("Setting log level to info.");
1697 break;
1698
1699 case 24:
1700 if (m->running_as == SYSTEMD_USER) {
1701 m->exit_code = MANAGER_EXIT;
1702 return 0;
1703 }
1704
1705 /* This is a nop on init */
1706 break;
1707
1708 case 26:
1709 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1710 log_notice("Setting log target to journal-or-kmsg.");
1711 break;
1712
1713 case 27:
1714 log_set_target(LOG_TARGET_CONSOLE);
1715 log_notice("Setting log target to console.");
1716 break;
1717
1718 case 28:
1719 log_set_target(LOG_TARGET_KMSG);
1720 log_notice("Setting log target to kmsg.");
1721 break;
1722
1723 case 29:
1724 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1725 log_notice("Setting log target to syslog-or-kmsg.");
1726 break;
1727
1728 default:
1729 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1730 }
1731 }
1732 }
1733 }
1734
1735 if (sigchld)
1736 manager_dispatch_sigchld(m);
1737
1738 return 0;
1739 }
1740
1741 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1742 Manager *m = userdata;
1743 Iterator i;
1744 Unit *u;
1745
1746 assert(m);
1747 assert(m->time_change_fd == fd);
1748
1749 log_struct(LOG_INFO,
1750 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1751 "MESSAGE=Time has been changed",
1752 NULL);
1753
1754 /* Restart the watch */
1755 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1756
1757 close_nointr_nofail(m->time_change_fd);
1758 m->time_change_fd = -1;
1759
1760 manager_setup_time_change(m);
1761
1762 HASHMAP_FOREACH(u, m->units, i)
1763 if (UNIT_VTABLE(u)->time_change)
1764 UNIT_VTABLE(u)->time_change(u);
1765
1766 return 0;
1767 }
1768
1769 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1770 Manager *m = userdata;
1771
1772 assert(m);
1773 assert(m->idle_pipe[2] == fd);
1774
1775 m->no_console_output = m->n_on_console > 0;
1776
1777 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1778 manager_close_idle_pipe(m);
1779
1780 return 0;
1781 }
1782
1783 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1784 Manager *m = userdata;
1785 int r;
1786 uint64_t next;
1787
1788 assert(m);
1789 assert(source);
1790
1791 manager_print_jobs_in_progress(m);
1792
1793 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1794 r = sd_event_source_set_time(source, next);
1795 if (r < 0)
1796 return r;
1797
1798 return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1799 }
1800
1801 int manager_loop(Manager *m) {
1802 int r;
1803
1804 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1805
1806 assert(m);
1807 m->exit_code = MANAGER_RUNNING;
1808
1809 /* Release the path cache */
1810 set_free_free(m->unit_path_cache);
1811 m->unit_path_cache = NULL;
1812
1813 manager_check_finished(m);
1814
1815 /* There might still be some zombies hanging around from
1816 * before we were exec()'ed. Let's reap them. */
1817 r = manager_dispatch_sigchld(m);
1818 if (r < 0)
1819 return r;
1820
1821 while (m->exit_code == MANAGER_RUNNING) {
1822 usec_t wait_usec;
1823
1824 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1825 watchdog_ping();
1826
1827 if (!ratelimit_test(&rl)) {
1828 /* Yay, something is going seriously wrong, pause a little */
1829 log_warning("Looping too fast. Throttling execution a little.");
1830 sleep(1);
1831 continue;
1832 }
1833
1834 if (manager_dispatch_load_queue(m) > 0)
1835 continue;
1836
1837 if (manager_dispatch_gc_queue(m) > 0)
1838 continue;
1839
1840 if (manager_dispatch_cleanup_queue(m) > 0)
1841 continue;
1842
1843 if (manager_dispatch_cgroup_queue(m) > 0)
1844 continue;
1845
1846 if (manager_dispatch_dbus_queue(m) > 0)
1847 continue;
1848
1849 /* Sleep for half the watchdog time */
1850 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1851 wait_usec = m->runtime_watchdog / 2;
1852 if (wait_usec <= 0)
1853 wait_usec = 1;
1854 } else
1855 wait_usec = (usec_t) -1;
1856
1857 r = sd_event_run(m->event, wait_usec);
1858 if (r < 0) {
1859 log_error("Failed to run event loop: %s", strerror(-r));
1860 return r;
1861 }
1862 }
1863
1864 return m->exit_code;
1865 }
1866
1867 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1868 _cleanup_free_ char *n = NULL;
1869 Unit *u;
1870 int r;
1871
1872 assert(m);
1873 assert(s);
1874 assert(_u);
1875
1876 r = unit_name_from_dbus_path(s, &n);
1877 if (r < 0)
1878 return r;
1879
1880 r = manager_load_unit(m, n, NULL, e, &u);
1881 if (r < 0)
1882 return r;
1883
1884 *_u = u;
1885
1886 return 0;
1887 }
1888
1889 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1890 const char *p;
1891 unsigned id;
1892 Job *j;
1893 int r;
1894
1895 assert(m);
1896 assert(s);
1897 assert(_j);
1898
1899 p = startswith(s, "/org/freedesktop/systemd1/job/");
1900 if (!p)
1901 return -EINVAL;
1902
1903 r = safe_atou(p, &id);
1904 if (r < 0)
1905 return r;
1906
1907 j = manager_get_job(m, id);
1908 if (!j)
1909 return -ENOENT;
1910
1911 *_j = j;
1912
1913 return 0;
1914 }
1915
1916 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1917
1918 #ifdef HAVE_AUDIT
1919 _cleanup_free_ char *p = NULL;
1920 int audit_fd;
1921
1922 audit_fd = get_audit_fd();
1923 if (audit_fd < 0)
1924 return;
1925
1926 /* Don't generate audit events if the service was already
1927 * started and we're just deserializing */
1928 if (m->n_reloading > 0)
1929 return;
1930
1931 if (m->running_as != SYSTEMD_SYSTEM)
1932 return;
1933
1934 if (u->type != UNIT_SERVICE)
1935 return;
1936
1937 p = unit_name_to_prefix_and_instance(u->id);
1938 if (!p) {
1939 log_error_unit(u->id,
1940 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1941 return;
1942 }
1943
1944 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1945 if (errno == EPERM) {
1946 /* We aren't allowed to send audit messages?
1947 * Then let's not retry again. */
1948 close_audit_fd();
1949 } else
1950 log_warning("Failed to send audit message: %m");
1951 }
1952 #endif
1953
1954 }
1955
1956 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1957 union sockaddr_union sa = {
1958 .sa.sa_family = AF_UNIX,
1959 .un.sun_path = "\0/org/freedesktop/plymouthd",
1960 };
1961
1962 int n = 0;
1963 _cleanup_free_ char *message = NULL;
1964 _cleanup_close_ int fd = -1;
1965
1966 /* Don't generate plymouth events if the service was already
1967 * started and we're just deserializing */
1968 if (m->n_reloading > 0)
1969 return;
1970
1971 if (m->running_as != SYSTEMD_SYSTEM)
1972 return;
1973
1974 if (detect_container(NULL) > 0)
1975 return;
1976
1977 if (u->type != UNIT_SERVICE &&
1978 u->type != UNIT_MOUNT &&
1979 u->type != UNIT_SWAP)
1980 return;
1981
1982 /* We set SOCK_NONBLOCK here so that we rather drop the
1983 * message then wait for plymouth */
1984 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1985 if (fd < 0) {
1986 log_error("socket() failed: %m");
1987 return;
1988 }
1989
1990 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1991
1992 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
1993 log_error("connect() failed: %m");
1994 return;
1995 }
1996
1997 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1998 log_oom();
1999 return;
2000 }
2001
2002 errno = 0;
2003 if (write(fd, message, n + 1) != n + 1)
2004 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2005 log_error("Failed to write Plymouth message: %m");
2006 }
2007
2008 void manager_dispatch_bus_name_owner_changed(
2009 Manager *m,
2010 const char *name,
2011 const char* old_owner,
2012 const char *new_owner) {
2013
2014 Unit *u;
2015
2016 assert(m);
2017 assert(name);
2018
2019 u = hashmap_get(m->watch_bus, name);
2020 if (!u)
2021 return;
2022
2023 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2024 }
2025
2026 int manager_open_serialization(Manager *m, FILE **_f) {
2027 const char *path;
2028 int fd = -1;
2029 FILE *f;
2030
2031 assert(_f);
2032
2033 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2034 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2035 if (fd < 0)
2036 return -errno;
2037
2038 log_debug("Serializing state to %s", path);
2039
2040 f = fdopen(fd, "w+");
2041 if (!f) {
2042 close_nointr_nofail(fd);
2043 return -errno;
2044 }
2045
2046 *_f = f;
2047
2048 return 0;
2049 }
2050
2051 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2052 Iterator i;
2053 Unit *u;
2054 const char *t;
2055 char **e;
2056 int r;
2057
2058 assert(m);
2059 assert(f);
2060 assert(fds);
2061
2062 m->n_reloading ++;
2063
2064 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2065 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2066 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2067 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2068
2069 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2070 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2071 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2072 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2073
2074 if (!in_initrd()) {
2075 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2076 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2077 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2078 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2079 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2080 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2081 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2082 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2083 }
2084
2085 if (!switching_root) {
2086 STRV_FOREACH(e, m->environment) {
2087 _cleanup_free_ char *ce;
2088
2089 ce = cescape(*e);
2090 if (!ce)
2091 return -ENOMEM;
2092
2093 fprintf(f, "env=%s\n", *e);
2094 }
2095 }
2096
2097 if (m->notify_fd >= 0) {
2098 int copy;
2099
2100 copy = fdset_put_dup(fds, m->notify_fd);
2101 if (copy < 0)
2102 return copy;
2103
2104 fprintf(f, "notify-fd=%i\n", copy);
2105 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2106 }
2107
2108 if (m->kdbus_fd >= 0) {
2109 int copy;
2110
2111 copy = fdset_put_dup(fds, m->kdbus_fd);
2112 if (copy < 0)
2113 return copy;
2114
2115 fprintf(f, "kdbus-fd=%i\n", copy);
2116 }
2117
2118 bus_serialize(m, f);
2119
2120 fputc('\n', f);
2121
2122 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2123 if (u->id != t)
2124 continue;
2125
2126 if (!unit_can_serialize(u))
2127 continue;
2128
2129 /* Start marker */
2130 fputs(u->id, f);
2131 fputc('\n', f);
2132
2133 r = unit_serialize(u, f, fds, !switching_root);
2134 if (r < 0) {
2135 m->n_reloading --;
2136 return r;
2137 }
2138 }
2139
2140 assert(m->n_reloading > 0);
2141 m->n_reloading --;
2142
2143 if (ferror(f))
2144 return -EIO;
2145
2146 r = bus_fdset_add_all(m, fds);
2147 if (r < 0)
2148 return r;
2149
2150 return 0;
2151 }
2152
2153 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2154 int r = 0;
2155
2156 assert(m);
2157 assert(f);
2158
2159 log_debug("Deserializing state...");
2160
2161 m->n_reloading ++;
2162
2163 for (;;) {
2164 char line[LINE_MAX], *l;
2165
2166 if (!fgets(line, sizeof(line), f)) {
2167 if (feof(f))
2168 r = 0;
2169 else
2170 r = -errno;
2171
2172 goto finish;
2173 }
2174
2175 char_array_0(line);
2176 l = strstrip(line);
2177
2178 if (l[0] == 0)
2179 break;
2180
2181 if (startswith(l, "current-job-id=")) {
2182 uint32_t id;
2183
2184 if (safe_atou32(l+15, &id) < 0)
2185 log_debug("Failed to parse current job id value %s", l+15);
2186 else
2187 m->current_job_id = MAX(m->current_job_id, id);
2188
2189 } else if (startswith(l, "n-installed-jobs=")) {
2190 uint32_t n;
2191
2192 if (safe_atou32(l+17, &n) < 0)
2193 log_debug("Failed to parse installed jobs counter %s", l+17);
2194 else
2195 m->n_installed_jobs += n;
2196
2197 } else if (startswith(l, "n-failed-jobs=")) {
2198 uint32_t n;
2199
2200 if (safe_atou32(l+14, &n) < 0)
2201 log_debug("Failed to parse failed jobs counter %s", l+14);
2202 else
2203 m->n_failed_jobs += n;
2204
2205 } else if (startswith(l, "taint-usr=")) {
2206 int b;
2207
2208 b = parse_boolean(l+10);
2209 if (b < 0)
2210 log_debug("Failed to parse taint /usr flag %s", l+10);
2211 else
2212 m->taint_usr = m->taint_usr || b;
2213
2214 } else if (startswith(l, "firmware-timestamp="))
2215 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2216 else if (startswith(l, "loader-timestamp="))
2217 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2218 else if (startswith(l, "kernel-timestamp="))
2219 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2220 else if (startswith(l, "initrd-timestamp="))
2221 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2222 else if (startswith(l, "userspace-timestamp="))
2223 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2224 else if (startswith(l, "finish-timestamp="))
2225 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2226 else if (startswith(l, "security-start-timestamp="))
2227 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2228 else if (startswith(l, "security-finish-timestamp="))
2229 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2230 else if (startswith(l, "generators-start-timestamp="))
2231 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2232 else if (startswith(l, "generators-finish-timestamp="))
2233 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2234 else if (startswith(l, "units-load-start-timestamp="))
2235 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2236 else if (startswith(l, "units-load-finish-timestamp="))
2237 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2238 else if (startswith(l, "env=")) {
2239 _cleanup_free_ char *uce = NULL;
2240 char **e;
2241
2242 uce = cunescape(l+4);
2243 if (!uce) {
2244 r = -ENOMEM;
2245 goto finish;
2246 }
2247
2248 e = strv_env_set(m->environment, uce);
2249 if (!e) {
2250 r = -ENOMEM;
2251 goto finish;
2252 }
2253
2254 strv_free(m->environment);
2255 m->environment = e;
2256
2257 } else if (startswith(l, "notify-fd=")) {
2258 int fd;
2259
2260 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2261 log_debug("Failed to parse notify fd: %s", l + 10);
2262 else {
2263 if (m->notify_fd >= 0) {
2264 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2265 close_nointr_nofail(m->notify_fd);
2266 }
2267
2268 m->notify_fd = fdset_remove(fds, fd);
2269 }
2270
2271 } else if (startswith(l, "notify-socket=")) {
2272 char *n;
2273
2274 n = strdup(l+14);
2275 if (!n) {
2276 r = -ENOMEM;
2277 goto finish;
2278 }
2279
2280 free(m->notify_socket);
2281 m->notify_socket = n;
2282
2283 } else if (startswith(l, "kdbus-fd=")) {
2284 int fd;
2285
2286 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2287 log_debug("Failed to parse kdbus fd: %s", l + 9);
2288 else {
2289 if (m->kdbus_fd >= 0)
2290 close_nointr_nofail(m->kdbus_fd);
2291
2292 m->kdbus_fd = fdset_remove(fds, fd);
2293 }
2294
2295 } else if (bus_deserialize_item(m, l) == 0)
2296 log_debug("Unknown serialization item '%s'", l);
2297 }
2298
2299 for (;;) {
2300 Unit *u;
2301 char name[UNIT_NAME_MAX+2];
2302
2303 /* Start marker */
2304 if (!fgets(name, sizeof(name), f)) {
2305 if (feof(f))
2306 r = 0;
2307 else
2308 r = -errno;
2309
2310 goto finish;
2311 }
2312
2313 char_array_0(name);
2314
2315 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2316 if (r < 0)
2317 goto finish;
2318
2319 r = unit_deserialize(u, f, fds);
2320 if (r < 0)
2321 goto finish;
2322 }
2323
2324 finish:
2325 if (ferror(f))
2326 r = -EIO;
2327
2328 assert(m->n_reloading > 0);
2329 m->n_reloading --;
2330
2331 return r;
2332 }
2333
2334 int manager_reload(Manager *m) {
2335 int r, q;
2336 _cleanup_fclose_ FILE *f = NULL;
2337 _cleanup_fdset_free_ FDSet *fds = NULL;
2338
2339 assert(m);
2340
2341 r = manager_open_serialization(m, &f);
2342 if (r < 0)
2343 return r;
2344
2345 m->n_reloading ++;
2346 bus_manager_send_reloading(m, true);
2347
2348 fds = fdset_new();
2349 if (!fds) {
2350 m->n_reloading --;
2351 return -ENOMEM;
2352 }
2353
2354 r = manager_serialize(m, f, fds, false);
2355 if (r < 0) {
2356 m->n_reloading --;
2357 return r;
2358 }
2359
2360 if (fseeko(f, 0, SEEK_SET) < 0) {
2361 m->n_reloading --;
2362 return -errno;
2363 }
2364
2365 /* From here on there is no way back. */
2366 manager_clear_jobs_and_units(m);
2367 manager_undo_generators(m);
2368 lookup_paths_free(&m->lookup_paths);
2369
2370 /* Find new unit paths */
2371 manager_run_generators(m);
2372
2373 q = lookup_paths_init(
2374 &m->lookup_paths, m->running_as, true,
2375 m->generator_unit_path,
2376 m->generator_unit_path_early,
2377 m->generator_unit_path_late);
2378 if (q < 0)
2379 r = q;
2380
2381 manager_build_unit_path_cache(m);
2382
2383 /* First, enumerate what we can from all config files */
2384 q = manager_enumerate(m);
2385 if (q < 0)
2386 r = q;
2387
2388 /* Second, deserialize our stored data */
2389 q = manager_deserialize(m, f, fds);
2390 if (q < 0)
2391 r = q;
2392
2393 fclose(f);
2394 f = NULL;
2395
2396 /* Re-register notify_fd as event source */
2397 q = manager_setup_notify(m);
2398 if (q < 0)
2399 r = q;
2400
2401 /* Third, fire things up! */
2402 q = manager_coldplug(m);
2403 if (q < 0)
2404 r = q;
2405
2406 assert(m->n_reloading > 0);
2407 m->n_reloading--;
2408
2409 m->send_reloading_done = true;
2410
2411 return r;
2412 }
2413
2414 static bool manager_is_booting_or_shutting_down(Manager *m) {
2415 Unit *u;
2416
2417 assert(m);
2418
2419 /* Is the initial job still around? */
2420 if (manager_get_job(m, m->default_unit_job_id))
2421 return true;
2422
2423 /* Is there a job for the shutdown target? */
2424 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2425 if (u)
2426 return !!u->job;
2427
2428 return false;
2429 }
2430
2431 bool manager_is_reloading_or_reexecuting(Manager *m) {
2432 assert(m);
2433
2434 return m->n_reloading != 0;
2435 }
2436
2437 void manager_reset_failed(Manager *m) {
2438 Unit *u;
2439 Iterator i;
2440
2441 assert(m);
2442
2443 HASHMAP_FOREACH(u, m->units, i)
2444 unit_reset_failed(u);
2445 }
2446
2447 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2448 Unit *u;
2449
2450 assert(m);
2451 assert(name);
2452
2453 /* Returns true if the unit is inactive or going down */
2454 u = manager_get_unit(m, name);
2455 if (!u)
2456 return true;
2457
2458 return unit_inactive_or_pending(u);
2459 }
2460
2461 void manager_check_finished(Manager *m) {
2462 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2463 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2464
2465 assert(m);
2466
2467 if (m->n_running_jobs == 0)
2468 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2469
2470 if (hashmap_size(m->jobs) > 0) {
2471 if (m->jobs_in_progress_event_source) {
2472 uint64_t next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
2473 sd_event_source_set_time(m->jobs_in_progress_event_source, next);
2474 }
2475 return;
2476 }
2477
2478 manager_flip_auto_status(m, false);
2479
2480 /* Notify Type=idle units that we are done now */
2481 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2482 manager_close_idle_pipe(m);
2483
2484 /* Turn off confirm spawn now */
2485 m->confirm_spawn = false;
2486
2487 if (dual_timestamp_is_set(&m->finish_timestamp))
2488 return;
2489
2490 dual_timestamp_get(&m->finish_timestamp);
2491
2492 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2493
2494 /* Note that m->kernel_usec.monotonic is always at 0,
2495 * and m->firmware_usec.monotonic and
2496 * m->loader_usec.monotonic should be considered
2497 * negative values. */
2498
2499 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2500 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2501 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2502 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2503
2504 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2505
2506 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2507 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2508
2509 if (!log_on_console())
2510 log_struct(LOG_INFO,
2511 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2512 "KERNEL_USEC="USEC_FMT, kernel_usec,
2513 "INITRD_USEC="USEC_FMT, initrd_usec,
2514 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2515 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2516 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2517 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2518 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2519 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2520 NULL);
2521 } else {
2522 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2523 initrd_usec = 0;
2524
2525 if (!log_on_console())
2526 log_struct(LOG_INFO,
2527 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2528 "KERNEL_USEC="USEC_FMT, kernel_usec,
2529 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2530 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2531 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2532 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2533 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2534 NULL);
2535 }
2536 } else {
2537 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2538 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2539
2540 if (!log_on_console())
2541 log_struct(LOG_INFO,
2542 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2543 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2544 "MESSAGE=Startup finished in %s.",
2545 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2546 NULL);
2547 }
2548
2549 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2550
2551 sd_notifyf(false,
2552 "READY=1\nSTATUS=Startup finished in %s.",
2553 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2554 }
2555
2556 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2557 char *p;
2558 int r;
2559
2560 assert(m);
2561 assert(generator);
2562 assert(name);
2563
2564 if (*generator)
2565 return 0;
2566
2567 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2568 /* systemd --system, not running --test */
2569
2570 p = strappend("/run/systemd/", name);
2571 if (!p)
2572 return log_oom();
2573
2574 r = mkdir_p_label(p, 0755);
2575 if (r < 0) {
2576 log_error("Failed to create generator directory %s: %s",
2577 p, strerror(-r));
2578 free(p);
2579 return r;
2580 }
2581 } else if (m->running_as == SYSTEMD_USER) {
2582 const char *s = NULL;
2583
2584 s = getenv("XDG_RUNTIME_DIR");
2585 if (!s)
2586 return -EINVAL;
2587 p = strjoin(s, "/systemd/", name, NULL);
2588 if (!p)
2589 return log_oom();
2590
2591 r = mkdir_p_label(p, 0755);
2592 if (r < 0) {
2593 log_error("Failed to create generator directory %s: %s",
2594 p, strerror(-r));
2595 free(p);
2596 return r;
2597 }
2598 } else {
2599 /* systemd --system --test */
2600
2601 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2602 if (!p)
2603 return log_oom();
2604
2605 if (!mkdtemp(p)) {
2606 log_error("Failed to create generator directory %s: %m",
2607 p);
2608 free(p);
2609 return -errno;
2610 }
2611 }
2612
2613 *generator = p;
2614 return 0;
2615 }
2616
2617 static void trim_generator_dir(Manager *m, char **generator) {
2618 assert(m);
2619 assert(generator);
2620
2621 if (!*generator)
2622 return;
2623
2624 if (rmdir(*generator) >= 0) {
2625 free(*generator);
2626 *generator = NULL;
2627 }
2628
2629 return;
2630 }
2631
2632 void manager_run_generators(Manager *m) {
2633 _cleanup_closedir_ DIR *d = NULL;
2634 const char *generator_path;
2635 const char *argv[5];
2636 int r;
2637
2638 assert(m);
2639
2640 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2641 d = opendir(generator_path);
2642 if (!d) {
2643 if (errno == ENOENT)
2644 return;
2645
2646 log_error("Failed to enumerate generator directory %s: %m",
2647 generator_path);
2648 return;
2649 }
2650
2651 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2652 if (r < 0)
2653 goto finish;
2654
2655 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2656 if (r < 0)
2657 goto finish;
2658
2659 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2660 if (r < 0)
2661 goto finish;
2662
2663 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2664 argv[1] = m->generator_unit_path;
2665 argv[2] = m->generator_unit_path_early;
2666 argv[3] = m->generator_unit_path_late;
2667 argv[4] = NULL;
2668
2669 RUN_WITH_UMASK(0022)
2670 execute_directory(generator_path, d, (char**) argv);
2671
2672 finish:
2673 trim_generator_dir(m, &m->generator_unit_path);
2674 trim_generator_dir(m, &m->generator_unit_path_early);
2675 trim_generator_dir(m, &m->generator_unit_path_late);
2676 }
2677
2678 static void remove_generator_dir(Manager *m, char **generator) {
2679 assert(m);
2680 assert(generator);
2681
2682 if (!*generator)
2683 return;
2684
2685 strv_remove(m->lookup_paths.unit_path, *generator);
2686 rm_rf(*generator, false, true, false);
2687
2688 free(*generator);
2689 *generator = NULL;
2690 }
2691
2692 void manager_undo_generators(Manager *m) {
2693 assert(m);
2694
2695 remove_generator_dir(m, &m->generator_unit_path);
2696 remove_generator_dir(m, &m->generator_unit_path_early);
2697 remove_generator_dir(m, &m->generator_unit_path_late);
2698 }
2699
2700 int manager_environment_add(Manager *m, char **minus, char **plus) {
2701 char **a = NULL, **b = NULL, **l;
2702 assert(m);
2703
2704 l = m->environment;
2705
2706 if (!strv_isempty(minus)) {
2707 a = strv_env_delete(l, 1, minus);
2708 if (!a)
2709 return -ENOMEM;
2710
2711 l = a;
2712 }
2713
2714 if (!strv_isempty(plus)) {
2715 b = strv_env_merge(2, l, plus);
2716 if (!b)
2717 return -ENOMEM;
2718
2719 l = b;
2720 }
2721
2722 if (m->environment != l)
2723 strv_free(m->environment);
2724 if (a != l)
2725 strv_free(a);
2726 if (b != l)
2727 strv_free(b);
2728
2729 m->environment = l;
2730 manager_clean_environment(m);
2731 strv_sort(m->environment);
2732
2733 return 0;
2734 }
2735
2736 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2737 int i;
2738
2739 assert(m);
2740
2741 for (i = 0; i < RLIMIT_NLIMITS; i++) {
2742 if (!default_rlimit[i])
2743 continue;
2744
2745 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2746 if (!m->rlimit[i])
2747 return -ENOMEM;
2748 }
2749
2750 return 0;
2751 }
2752
2753 void manager_recheck_journal(Manager *m) {
2754 Unit *u;
2755
2756 assert(m);
2757
2758 if (m->running_as != SYSTEMD_SYSTEM)
2759 return;
2760
2761 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2762 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2763 log_close_journal();
2764 return;
2765 }
2766
2767 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2768 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2769 log_close_journal();
2770 return;
2771 }
2772
2773 /* Hmm, OK, so the socket is fully up and the service is up
2774 * too, then let's make use of the thing. */
2775 log_open();
2776 }
2777
2778 void manager_set_show_status(Manager *m, ShowStatus mode) {
2779 assert(m);
2780 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2781
2782 if (m->running_as != SYSTEMD_SYSTEM)
2783 return;
2784
2785 m->show_status = mode;
2786
2787 if (mode > 0)
2788 touch("/run/systemd/show-status");
2789 else
2790 unlink("/run/systemd/show-status");
2791 }
2792
2793 static bool manager_get_show_status(Manager *m) {
2794 assert(m);
2795
2796 if (m->running_as != SYSTEMD_SYSTEM)
2797 return false;
2798
2799 if (m->no_console_output)
2800 return false;
2801
2802 if (m->show_status > 0)
2803 return true;
2804
2805 /* If Plymouth is running make sure we show the status, so
2806 * that there's something nice to see when people press Esc */
2807
2808 return plymouth_running();
2809 }
2810
2811 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2812 va_list ap;
2813
2814 if (!manager_get_show_status(m))
2815 return;
2816
2817 /* XXX We should totally drop the check for ephemeral here
2818 * and thus effectively make 'Type=idle' pointless. */
2819 if (ephemeral && m->n_on_console > 0)
2820 return;
2821
2822 if (!manager_is_booting_or_shutting_down(m))
2823 return;
2824
2825 va_start(ap, format);
2826 status_vprintf(status, true, ephemeral, format, ap);
2827 va_end(ap);
2828 }
2829
2830 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2831 _cleanup_free_ char *p = NULL;
2832 Unit *found;
2833
2834 assert(m);
2835 assert(path);
2836 assert(suffix);
2837 assert(_found);
2838
2839 p = unit_name_from_path(path, suffix);
2840 if (!p)
2841 return -ENOMEM;
2842
2843 found = manager_get_unit(m, p);
2844 if (!found) {
2845 *_found = NULL;
2846 return 0;
2847 }
2848
2849 *_found = found;
2850 return 1;
2851 }
2852
2853 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2854 char p[strlen(path)+1];
2855
2856 assert(m);
2857 assert(path);
2858
2859 strcpy(p, path);
2860 path_kill_slashes(p);
2861
2862 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2863 }
Unnamed repository; edit this file 'description' to name the repository.