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