]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/manager.c
projects / thirdparty / systemd.git / blob
? search:


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