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