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