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