]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/manager.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
man: add table of manager states
[thirdparty/systemd.git] / src / core / manager.c
CommitLineData
d6c9574f 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
60918275 2
a7334b09
LP		 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
5430f7f2
LP		 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
a7334b09
LP		 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
5430f7f2 16 Lesser General Public License for more details.
a7334b09 17
5430f7f2 18 You should have received a copy of the GNU Lesser General Public License
a7334b09
LP		 19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
60918275
LP		 22#include <assert.h>
23#include <errno.h>
87d1515d 24#include <string.h>
9152c765 25#include <signal.h>
9152c765
LP		 26#include <sys/wait.h>
27#include <unistd.h>
e46b13c8
ZJS		 28#include <sys/inotify.h>
29#include <sys/epoll.h>
9152c765 30#include <sys/poll.h>
e1414003
LP		 31#include <sys/reboot.h>
32#include <sys/ioctl.h>
33#include <linux/kd.h>
80876c20
LP		 34#include <termios.h>
35#include <fcntl.h>
a16e1123
LP		 36#include <sys/types.h>
37#include <sys/stat.h>
fe51822e 38#include <dirent.h>
8742514c 39#include <sys/timerfd.h>
830f6caa
LP		 40
41#ifdef HAVE_AUDIT
4927fcae 42#include <libaudit.h>
830f6caa 43#endif
60918275 44
718db961
LP		 45#include "sd-daemon.h"
46#include "sd-id128.h"
47#include "sd-messages.h"
81527be1 48
60918275 49#include "manager.h"
75778e21 50#include "transaction.h"
60918275
LP		 51#include "hashmap.h"
52#include "macro.h"
53#include "strv.h"
16354eff 54#include "log.h"
2a987ee8 55#include "util.h"
49e942b2 56#include "mkdir.h"
ea430986 57#include "ratelimit.h"
e21fea24 58#include "locale-setup.h"
8e274523 59#include "mount-setup.h"
9e2f7c11 60#include "unit-name.h"
1137a57c 61#include "missing.h"
84e3543e 62#include "path-lookup.h"
514f4ef5 63#include "special.h"
d06dacd0 64#include "exit-status.h"
5dc4c17f 65#include "virt.h"
e96d6be7 66#include "watchdog.h"
b59e2465 67#include "cgroup-util.h"
9eb977db 68#include "path-util.h"
c1165f82 69#include "audit-fd.h"
c51d84dc 70#include "boot-timestamps.h"
8b55b8c4 71#include "env-util.h"
718db961
LP		 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"
e3dd987c 79#include "bus-kernel.h"
e4746b57 80#include "time-util.h"
60918275 81
701cc384 82/* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
94b6dfa2 83#define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
701cc384 84
03b717a3 85/* Initial delay and the interval for printing status messages about running jobs */
fd08a840
ZJS		 86#define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
87#define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
03b717a3
MS		 88#define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
89
718db961
LP		 90static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
91static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
92static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
93static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
94static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
752b5905 95static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
718db961 96
03b717a3 97static int manager_watch_jobs_in_progress(Manager *m) {
e5723c89
ZJS		 98 usec_t next;
99
718db961 100 assert(m);
03b717a3 101
718db961 102 if (m->jobs_in_progress_event_source)
03b717a3
MS		 103 return 0;
104
e5723c89 105 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
6a0f1f6d
LP		 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);
03b717a3
MS		 112}
113
718db961 114#define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
03b717a3 115
03b717a3
MS		 116static 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) {
6282c859
MS		 123 if (pos > 2)
124 p = mempset(p, ' ', pos-2);
5052495b 125 p = stpcpy(p, ANSI_RED_ON);
03b717a3
MS		 126 *p++ = '*';
127 }
128
129 if (pos > 0 && pos <= width) {
5052495b 130 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
03b717a3
MS		 131 *p++ = '*';
132 }
133
5052495b 134 p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
03b717a3
MS		 135
136 if (pos < width) {
5052495b 137 p = stpcpy(p, ANSI_RED_ON);
03b717a3 138 *p++ = '*';
6282c859
MS		 139 if (pos < width-1)
140 p = mempset(p, ' ', width-1-pos);
51d122af 141 strcpy(p, ANSI_HIGHLIGHT_OFF);
03b717a3 142 }
03b717a3
MS		 143}
144
cb8ccb22 145void manager_flip_auto_status(Manager *m, bool enable) {
f755e3b7
LP		 146 assert(m);
147
cb8ccb22
ZJS		 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
03b717a3 157static void manager_print_jobs_in_progress(Manager *m) {
718db961 158 _cleanup_free_ char *job_of_n = NULL;
03b717a3
MS		 159 Iterator i;
160 Job *j;
03b717a3
MS		 161 unsigned counter = 0, print_nr;
162 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
163 unsigned cylon_pos;
8bb310c3
ZJS		 164 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
165 uint64_t x;
03b717a3 166
718db961
LP		 167 assert(m);
168
cb8ccb22 169 manager_flip_auto_status(m, true);
d450b6f2 170
03b717a3
MS		 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
e970a72e
MS		 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);
51d122af 180 assert(j);
5a82a91a 181
03b717a3
MS		 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
8bb310c3
ZJS		 187 m->jobs_in_progress_iteration++;
188
03b717a3
MS		 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
8bb310c3
ZJS		 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
6b02bce7 197 manager_status_printf(m, true, cylon,
8bb310c3
ZJS		 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);
03b717a3 203
03b717a3
MS		 204}
205
e46b13c8
ZJS		 206static 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
232static 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
249static 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
257static 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
31a7eb86 296static int manager_watch_idle_pipe(Manager *m) {
31a7eb86
ZJS		 297 int r;
298
718db961
LP		 299 assert(m);
300
301 if (m->idle_pipe_event_source)
31a7eb86
ZJS		 302 return 0;
303
304 if (m->idle_pipe[2] < 0)
305 return 0;
306
151b9b96 307 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
718db961
LP		 308 if (r < 0) {
309 log_error("Failed to watch idle pipe: %s", strerror(-r));
310 return r;
31a7eb86
ZJS		 311 }
312
31a7eb86 313 return 0;
31a7eb86
ZJS		 314}
315
718db961
LP		 316static void manager_close_idle_pipe(Manager *m) {
317 assert(m);
31a7eb86 318
3d94f76c
LP		 319 safe_close_pair(m->idle_pipe);
320 safe_close_pair(m->idle_pipe + 2);
31a7eb86
ZJS		 321}
322
8742514c 323static int manager_setup_time_change(Manager *m) {
718db961 324 int r;
b92bea5d
ZJS		 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 };
8742514c 331
718db961
LP		 332 assert(m);
333 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
8742514c 334
0d8c31ff
ZJS		 335 if (m->test_run)
336 return 0;
337
8742514c
LP		 338 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
339 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
340
718db961
LP		 341 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
342 if (m->time_change_fd < 0) {
8742514c
LP		 343 log_error("Failed to create timerfd: %m");
344 return -errno;
345 }
346
718db961 347 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
8742514c 348 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
03e334a1 349 m->time_change_fd = safe_close(m->time_change_fd);
8742514c
LP		 350 return 0;
351 }
352
151b9b96 353 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
718db961
LP		 354 if (r < 0) {
355 log_error("Failed to create time change event source: %s", strerror(-r));
356 return r;
8742514c
LP		 357 }
358
359 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
360
361 return 0;
362}
363
80876c20 364static int enable_special_signals(Manager *m) {
718db961 365 _cleanup_close_ int fd = -1;
80876c20
LP		 366
367 assert(m);
368
a41b539e 369 /* Enable that we get SIGINT on control-alt-del. In containers
c9999773
LP		 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)
80876c20
LP		 373 log_warning("Failed to enable ctrl-alt-del handling: %m");
374
a41b539e
LP		 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 {
80876c20
LP		 381 /* Enable that we get SIGWINCH on kbrequest */
382 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
f5f6d0e2 383 log_warning("Failed to enable kbrequest handling: %m");
80876c20
LP		 384 }
385
386 return 0;
387}
388
ce578209 389static int manager_setup_signals(Manager *m) {
b92bea5d
ZJS		 390 struct sigaction sa = {
391 .sa_handler = SIG_DFL,
392 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
393 };
718db961
LP		 394 sigset_t mask;
395 int r;
60918275 396
ce578209
LP		 397 assert(m);
398
0d8c31ff
ZJS		 399 if (m->test_run)
400 return 0;
401
57c0c30e
LP		 402 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
403
4dffec14
LP		 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). */
7d793605 408
4dffec14 409 assert_se(sigemptyset(&mask) == 0);
7d793605
LP		 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 */
4dffec14 419
7d793605 420 SIGRTMIN+0, /* systemd: start default.target */
0003d1ab 421 SIGRTMIN+1, /* systemd: isolate rescue.target */
7d793605
LP		 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 */
0003d1ab 426 SIGRTMIN+6, /* systemd: start kexec.target */
4dffec14
LP		 427
428 /* ... space for more special targets ... */
429
0003d1ab
LP		 430 SIGRTMIN+13, /* systemd: Immediate halt */
431 SIGRTMIN+14, /* systemd: Immediate poweroff */
432 SIGRTMIN+15, /* systemd: Immediate reboot */
433 SIGRTMIN+16, /* systemd: Immediate kexec */
4dffec14
LP		 434
435 /* ... space for more immediate system state changes ... */
436
0658666b
LP		 437 SIGRTMIN+20, /* systemd: enable status messages */
438 SIGRTMIN+21, /* systemd: disable status messages */
253ee27a
LP		 439 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
440 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
600b704e 441 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
4dffec14
LP		 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
4cfa2c99 454 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
253ee27a
LP		 455 SIGRTMIN+27, /* systemd: set log target to console */
456 SIGRTMIN+28, /* systemd: set log target to kmsg */
c1dc6153 457 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete)*/
4dffec14
LP		 458
459 /* ... one free signal here SIGRTMIN+30 ... */
460#endif
7d793605 461 -1);
ce578209
LP		 462 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
463
718db961
LP		 464 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
465 if (m->signal_fd < 0)
ce578209
LP		 466 return -errno;
467
151b9b96 468 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
718db961
LP		 469 if (r < 0)
470 return r;
ce578209 471
fa28bc2d 472 /* Process signals a bit earlier than the rest of things, but
46849c3f 473 * later than notify_fd processing, so that the notify
fa28bc2d
LP		 474 * processing can still figure out to which process/service a
475 * message belongs, before we reap the process. */
29083707
LP		 476 r = sd_event_source_set_priority(m->signal_event_source, -5);
477 if (r < 0)
478 return r;
479
67445f4e 480 if (m->running_as == SYSTEMD_SYSTEM)
80876c20 481 return enable_special_signals(m);
e1414003 482
ce578209
LP		 483 return 0;
484}
485
f069efb4
LP		 486static 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
e21fea24 503static int manager_default_environment(Manager *m) {
71ecc858
LP		 504 assert(m);
505
e21fea24
KS		 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. */
43638332
ZJS		 514 m->environment = strv_new("PATH=" DEFAULT_PATH,
515 NULL);
e21fea24
KS		 516
517 /* Import locale variables LC_*= from configuration */
518 locale_setup(&m->environment);
43d03a83 519 } else {
e21fea24
KS		 520 /* The user manager passes its own environment
521 * along to its children. */
522 m->environment = strv_copy(environ);
43d03a83
LP		 523 }
524
e21fea24
KS		 525 if (!m->environment)
526 return -ENOMEM;
8b55b8c4 527
f069efb4 528 manager_clean_environment(m);
9d5a3757
LP		 529 strv_sort(m->environment);
530
e21fea24 531 return 0;
71ecc858
LP		 532}
533
0d8c31ff 534int manager_new(SystemdRunningAs running_as, bool test_run, Manager **_m) {
ce578209 535 Manager *m;
e3dd987c 536 int r;
8e274523
LP		 537
538 assert(_m);
a5dab5ce 539 assert(running_as >= 0);
67445f4e 540 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
ce578209 541
915b3753
LP		 542 m = new0(Manager, 1);
543 if (!m)
8e274523 544 return -ENOMEM;
60918275 545
4f8d551f 546#ifdef ENABLE_EFI
530a9662 547 if (running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0)
c51d84dc 548 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
4f8d551f
ZC		 549#endif
550
a5dab5ce 551 m->running_as = running_as;
a16e1123 552 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
bd8f585b 553 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
80876c20 554
718db961 555 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
8742514c 556
e3dd987c 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;
ea430986 558 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
9152c765 559
e46b13c8
ZJS		 560 m->ask_password_inotify_fd = -1;
561 m->have_ask_password = -EINVAL; /* we don't know */
562
0d8c31ff
ZJS		 563 m->test_run = test_run;
564
e21fea24
KS		 565 r = manager_default_environment(m);
566 if (r < 0)
1137a57c
LP		 567 goto fail;
568
d5099efc 569 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
718db961 570 if (r < 0)
60918275
LP		 571 goto fail;
572
d5099efc 573 r = hashmap_ensure_allocated(&m->jobs, NULL);
718db961 574 if (r < 0)
60918275
LP		 575 goto fail;
576
d5099efc 577 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
718db961 578 if (r < 0)
9152c765
LP		 579 goto fail;
580
d5099efc 581 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
718db961 582 if (r < 0)
05e343b7
LP		 583 goto fail;
584
d5099efc 585 r = set_ensure_allocated(&m->startup_units, NULL);
95ae05c0
WC		 586 if (r < 0)
587 goto fail;
588
d5099efc 589 r = set_ensure_allocated(&m->failed_units, NULL);
f755e3b7
LP		 590 if (r < 0)
591 goto fail;
592
718db961
LP		 593 r = sd_event_default(&m->event);
594 if (r < 0)
8742514c
LP		 595 goto fail;
596
151b9b96 597 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
752b5905
LP		 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
8742514c
LP		 609 r = manager_setup_signals(m);
610 if (r < 0)
9152c765
LP		 611 goto fail;
612
8742514c
LP		 613 r = manager_setup_cgroup(m);
614 if (r < 0)
8e274523
LP		 615 goto fail;
616
8742514c
LP		 617 r = manager_setup_time_change(m);
618 if (r < 0)
8c47c732
LP		 619 goto fail;
620
9670d583
LP		 621 m->udev = udev_new();
622 if (!m->udev) {
623 r = -ENOMEM;
624 goto fail;
625 }
626
d86f9d52
LP		 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
72bc8d00
LP		 631 m->taint_usr = dir_is_empty("/usr") > 0;
632
8e274523
LP		 633 *_m = m;
634 return 0;
60918275
LP		 635
636fail:
637 manager_free(m);
8e274523 638 return r;
60918275
LP		 639}
640
d86f9d52 641static int manager_setup_notify(Manager *m) {
7181dbdb 642 int r;
d86f9d52 643
0d8c31ff
ZJS		 644 if (m->test_run)
645 return 0;
646
d86f9d52
LP		 647 if (m->notify_fd < 0) {
648 _cleanup_close_ int fd = -1;
55836941 649 union sockaddr_union sa = {
7181dbdb
LP		 650 .sa.sa_family = AF_UNIX,
651 };
55836941 652 static const int one = 1;
d86f9d52
LP		 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
7181dbdb
LP		 665 if (m->running_as == SYSTEMD_SYSTEM)
666 m->notify_socket = strdup("/run/systemd/notify");
667 else {
668 const char *e;
d86f9d52 669
7181dbdb
LP		 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));
d86f9d52 683 if (r < 0) {
70af4d17 684 log_error("bind(%s) failed: %m", sa.un.sun_path);
e7bc5196
ZJS		 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;
d86f9d52
LP		 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
d86f9d52
LP		 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) {
151b9b96 715 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
d86f9d52
LP		 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
733static int manager_setup_kdbus(Manager *m) {
5bf348d7 734#ifdef ENABLE_KDBUS
d86f9d52
LP		 735 _cleanup_free_ char *p = NULL;
736
737 assert(m);
738
0d8c31ff 739 if (m->test_run || m->kdbus_fd >= 0)
d86f9d52
LP		 740 return 0;
741
f2769777 742 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
d86f9d52
LP		 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. */
88c59cb3 754 if (m->running_as == SYSTEMD_SYSTEM)
486e99a3 755 mkdir_p_label("/dev/kdbus/domain", 0700);
d86f9d52
LP		 756#endif
757
758 return 0;
759}
760
761static int manager_connect_bus(Manager *m, bool reexecuting) {
762 bool try_bus_connect;
763
764 assert(m);
765
0d8c31ff
ZJS		 766 if (m->test_run)
767 return 0;
768
d86f9d52
LP		 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
23a177ef 778static unsigned manager_dispatch_cleanup_queue(Manager *m) {
595ed347 779 Unit *u;
23a177ef
LP		 780 unsigned n = 0;
781
782 assert(m);
783
595ed347
MS		 784 while ((u = m->cleanup_queue)) {
785 assert(u->in_cleanup_queue);
23a177ef 786
595ed347 787 unit_free(u);
23a177ef
LP		 788 n++;
789 }
790
791 return n;
792}
793
eced69b3 794enum {
35b8ca3a 795 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
eced69b3
LP		 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
802static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
701cc384
LP		 803 Iterator i;
804 Unit *other;
eced69b3 805 bool is_bad;
701cc384
LP		 806
807 assert(u);
808
ac155bb8
MS		 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)
701cc384
LP		 812 return;
813
ac155bb8 814 if (u->in_cleanup_queue)
701cc384
LP		 815 goto bad;
816
817 if (unit_check_gc(u))
818 goto good;
819
ac155bb8 820 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
eced69b3
LP		 821
822 is_bad = true;
823
ac155bb8 824 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
701cc384
LP		 825 unit_gc_sweep(other, gc_marker);
826
ac155bb8 827 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
701cc384 828 goto good;
eced69b3 829
ac155bb8 830 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
eced69b3 831 is_bad = false;
701cc384
LP		 832 }
833
eced69b3
LP		 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 */
ac155bb8 839 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
eced69b3
LP		 840 unit_add_to_gc_queue(u);
841 return;
842
701cc384 843bad:
eced69b3
LP		 844 /* We definitely know that this one is not useful anymore, so
845 * let's mark it for deletion */
ac155bb8 846 u->gc_marker = gc_marker + GC_OFFSET_BAD;
eced69b3 847 unit_add_to_cleanup_queue(u);
701cc384
LP		 848 return;
849
850good:
ac155bb8 851 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
701cc384
LP		 852}
853
854static unsigned manager_dispatch_gc_queue(Manager *m) {
595ed347 855 Unit *u;
701cc384 856 unsigned n = 0;
eced69b3 857 unsigned gc_marker;
701cc384
LP		 858
859 assert(m);
860
cf1265e1 861 /* log_debug("Running GC..."); */
701cc384 862
eced69b3
LP		 863 m->gc_marker += _GC_OFFSET_MAX;
864 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
c9c0cadb 865 m->gc_marker = 1;
701cc384 866
eced69b3
LP		 867 gc_marker = m->gc_marker;
868
595ed347
MS		 869 while ((u = m->gc_queue)) {
870 assert(u->in_gc_queue);
701cc384 871
595ed347 872 unit_gc_sweep(u, gc_marker);
eced69b3 873
71fda00f 874 LIST_REMOVE(gc_queue, m->gc_queue, u);
595ed347 875 u->in_gc_queue = false;
701cc384
LP		 876
877 n++;
878
595ed347
MS		 879 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
880 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
66870f90 881 log_debug_unit(u->id, "Collecting %s", u->id);
595ed347
MS		 882 u->gc_marker = gc_marker + GC_OFFSET_BAD;
883 unit_add_to_cleanup_queue(u);
701cc384
LP		 884 }
885 }
886
887 m->n_in_gc_queue = 0;
701cc384
LP		 888
889 return n;
890}
891
a16e1123 892static void manager_clear_jobs_and_units(Manager *m) {
a16e1123 893 Unit *u;
60918275
LP		 894
895 assert(m);
896
87f0e418
LP		 897 while ((u = hashmap_first(m->units)))
898 unit_free(u);
964e0949
LP		 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
964e0949
LP		 909 assert(hashmap_isempty(m->jobs));
910 assert(hashmap_isempty(m->units));
9e9e2b72
MS		 911
912 m->n_on_console = 0;
913 m->n_running_jobs = 0;
a16e1123
LP		 914}
915
916void manager_free(Manager *m) {
917 UnitType c;
c93ff2e9 918 int i;
87f0e418 919
a16e1123
LP		 920 assert(m);
921
922 manager_clear_jobs_and_units(m);
23a177ef 923
7824bbeb
LP		 924 for (c = 0; c < _UNIT_TYPE_MAX; c++)
925 if (unit_vtable[c]->shutdown)
926 unit_vtable[c]->shutdown(m);
927
a16e1123
LP		 928 /* If we reexecute ourselves, we keep the root cgroup
929 * around */
c6c18be3 930 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
8e274523 931
5a1e9937
LP		 932 manager_undo_generators(m);
933
5e8d1c9a 934 bus_done(m);
ea430986 935
87f0e418 936 hashmap_free(m->units);
60918275 937 hashmap_free(m->jobs);
5ba6985b
LP		 938 hashmap_free(m->watch_pids1);
939 hashmap_free(m->watch_pids2);
05e343b7 940 hashmap_free(m->watch_bus);
9152c765 941
95ae05c0 942 set_free(m->startup_units);
f755e3b7
LP		 943 set_free(m->failed_units);
944
718db961
LP		 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);
752b5905 950 sd_event_source_unref(m->run_queue_event_source);
718db961 951
03e334a1
LP		 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);
718db961 956
e46b13c8
ZJS		 957 manager_close_ask_password(m);
958
718db961
LP		 959 manager_close_idle_pipe(m);
960
9670d583 961 udev_unref(m->udev);
718db961 962 sd_event_unref(m->event);
60918275 963
c952c6ec
LP		 964 free(m->notify_socket);
965
84e3543e 966 lookup_paths_free(&m->lookup_paths);
1137a57c 967 strv_free(m->environment);
036643a2 968
4ad49000 969 hashmap_free(m->cgroup_unit);
c6c18be3 970 set_free_free(m->unit_path_cache);
33be102a 971
664f88a7
LP		 972 free(m->switch_root);
973 free(m->switch_root_init);
974
517d56b1 975 for (i = 0; i < _RLIMIT_MAX; i++)
c93ff2e9
FC		 976 free(m->rlimit[i]);
977
a57f7e2c
LP		 978 assert(hashmap_isempty(m->units_requiring_mounts_for));
979 hashmap_free(m->units_requiring_mounts_for);
980
60918275
LP		 981 free(m);
982}
983
a16e1123
LP		 984int manager_enumerate(Manager *m) {
985 int r = 0, q;
f50e0a01 986 UnitType c;
f50e0a01
LP		 987
988 assert(m);
989
a16e1123
LP		 990 /* Let's ask every type to load all units from disk/kernel
991 * that it might know */
f50e0a01 992 for (c = 0; c < _UNIT_TYPE_MAX; c++)
a57f7e2c
LP		 993 if (unit_vtable[c]->enumerate) {
994 q = unit_vtable[c]->enumerate(m);
995 if (q < 0)
a16e1123 996 r = q;
a57f7e2c 997 }
f50e0a01
LP		 998
999 manager_dispatch_load_queue(m);
a16e1123
LP		 1000 return r;
1001}
1002
9588bc32 1003static int manager_coldplug(Manager *m) {
8f8f05a9 1004 int r = 0;
a16e1123
LP		 1005 Iterator i;
1006 Unit *u;
1007 char *k;
1008
1009 assert(m);
f50e0a01
LP		 1010
1011 /* Then, let's set up their initial state. */
1012 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
8f8f05a9 1013 int q;
f50e0a01
LP		 1014
1015 /* ignore aliases */
ac155bb8 1016 if (u->id != k)
f50e0a01
LP		 1017 continue;
1018
8f8f05a9
LP		 1019 q = unit_coldplug(u);
1020 if (q < 0)
cca098b0 1021 r = q;
f50e0a01
LP		 1022 }
1023
a16e1123
LP		 1024 return r;
1025}
1026
fe51822e
LP		 1027static void manager_build_unit_path_cache(Manager *m) {
1028 char **i;
807d0cca 1029 _cleanup_closedir_ DIR *d = NULL;
fe51822e
LP		 1030 int r;
1031
1032 assert(m);
1033
1034 set_free_free(m->unit_path_cache);
1035
d5099efc 1036 m->unit_path_cache = set_new(&string_hash_ops);
874310b7 1037 if (!m->unit_path_cache) {
fe51822e
LP		 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
bd0af849
ZJS		 1048 d = opendir(*i);
1049 if (!d) {
874310b7
ZJS		 1050 if (errno != ENOENT)
1051 log_error("Failed to open directory %s: %m", *i);
fe51822e
LP		 1052 continue;
1053 }
1054
1055 while ((de = readdir(d))) {
1056 char *p;
1057
1058 if (ignore_file(de->d_name))
1059 continue;
1060
b7def684 1061 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
44d91056 1062 if (!p) {
fe51822e
LP		 1063 r = -ENOMEM;
1064 goto fail;
1065 }
1066
ef42202a
ZJS		 1067 r = set_consume(m->unit_path_cache, p);
1068 if (r < 0)
fe51822e 1069 goto fail;
fe51822e
LP		 1070 }
1071
1072 closedir(d);
1073 d = NULL;
1074 }
1075
1076 return;
1077
1078fail:
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;
fe51822e
LP		 1083}
1084
9588bc32
LP		 1085
1086static 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
a16e1123
LP		 1108int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1109 int r, q;
1110
1111 assert(m);
1112
518d10e9 1113 dual_timestamp_get(&m->generators_start_timestamp);
5a1e9937 1114 manager_run_generators(m);
518d10e9 1115 dual_timestamp_get(&m->generators_finish_timestamp);
5a1e9937 1116
07719a21
LP		 1117 r = lookup_paths_init(
1118 &m->lookup_paths, m->running_as, true,
12ed81d9 1119 NULL,
07719a21
LP		 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
fe51822e
LP		 1126 manager_build_unit_path_cache(m);
1127
9f611ad8
LP		 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)
a7556052 1132 m->n_reloading ++;
9f611ad8 1133
a16e1123 1134 /* First, enumerate what we can from all config files */
718db961 1135 dual_timestamp_get(&m->units_load_start_timestamp);
a16e1123 1136 r = manager_enumerate(m);
718db961 1137 dual_timestamp_get(&m->units_load_finish_timestamp);
a16e1123
LP		 1138
1139 /* Second, deserialize if there is something to deserialize */
1cd974ed
ZJS		 1140 if (serialization)
1141 r = manager_deserialize(m, serialization, fds);
a16e1123 1142
01e10de3
LP		 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);
1cd974ed 1149 if (q < 0 && r == 0)
01e10de3
LP		 1150 r = q;
1151 }
1152
d86f9d52
LP		 1153 /* We might have deserialized the notify fd, but if we didn't
1154 * then let's create the bus now */
1cd974ed
ZJS		 1155 q = manager_setup_notify(m);
1156 if (q < 0 && r == 0)
1157 r = q;
d86f9d52 1158
e3dd987c
LP		 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);
8f8f05a9 1163 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
e3dd987c 1164
a16e1123 1165 /* Third, fire things up! */
07719a21 1166 q = manager_coldplug(m);
1cd974ed 1167 if (q < 0 && r == 0)
a16e1123
LP		 1168 r = q;
1169
9f611ad8 1170 if (serialization) {
a7556052
LP		 1171 assert(m->n_reloading > 0);
1172 m->n_reloading --;
71445ae7
LP		 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;
9f611ad8
LP		 1178 }
1179
a16e1123 1180 return r;
f50e0a01
LP		 1181}
1182
718db961 1183int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
e5b5ae50 1184 int r;
7527cb52 1185 Transaction *tr;
e5b5ae50
LP		 1186
1187 assert(m);
1188 assert(type < _JOB_TYPE_MAX);
87f0e418 1189 assert(unit);
e5b5ae50 1190 assert(mode < _JOB_MODE_MAX);
60918275 1191
398ef8ba 1192 if (mode == JOB_ISOLATE && type != JOB_START) {
718db961 1193 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
c497c7a9 1194 return -EINVAL;
398ef8ba 1195 }
c497c7a9 1196
ac155bb8 1197 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
718db961 1198 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
2528a7a6
LP		 1199 return -EPERM;
1200 }
1201
66870f90
ZJS		 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));
9f04bd52 1205
e0209d83
MS		 1206 job_type_collapse(&type, unit);
1207
23ade460 1208 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
7527cb52
MS		 1209 if (!tr)
1210 return -ENOMEM;
11dd41ce 1211
7527cb52
MS		 1212 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1213 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
b94fbd30 1214 mode == JOB_IGNORE_DEPENDENCIES, e);
7527cb52
MS		 1215 if (r < 0)
1216 goto tr_abort;
c497c7a9 1217
7527cb52
MS		 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;
e5b5ae50 1227
66870f90
ZJS		 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);
f50e0a01 1231
e5b5ae50 1232 if (_ret)
b94fbd30 1233 *_ret = tr->anchor_job;
60918275 1234
7527cb52 1235 transaction_free(tr);
e5b5ae50 1236 return 0;
7527cb52
MS		 1237
1238tr_abort:
1239 transaction_abort(tr);
1240 transaction_free(tr);
1241 return r;
e5b5ae50 1242}
60918275 1243
718db961 1244int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
28247076
LP		 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
c3090674
LP		 1253 r = manager_load_unit(m, name, NULL, NULL, &unit);
1254 if (r < 0)
28247076
LP		 1255 return r;
1256
398ef8ba 1257 return manager_add_job(m, type, unit, mode, override, e, _ret);
28247076
LP		 1258}
1259
60918275
LP		 1260Job *manager_get_job(Manager *m, uint32_t id) {
1261 assert(m);
1262
1263 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1264}
1265
87f0e418 1266Unit *manager_get_unit(Manager *m, const char *name) {
60918275
LP		 1267 assert(m);
1268 assert(name);
1269
87f0e418 1270 return hashmap_get(m->units, name);
60918275
LP		 1271}
1272
c1e1601e 1273unsigned manager_dispatch_load_queue(Manager *m) {
595ed347 1274 Unit *u;
c1e1601e 1275 unsigned n = 0;
60918275
LP		 1276
1277 assert(m);
1278
223dabab
LP		 1279 /* Make sure we are not run recursively */
1280 if (m->dispatching_load_queue)
c1e1601e 1281 return 0;
223dabab
LP		 1282
1283 m->dispatching_load_queue = true;
1284
87f0e418 1285 /* Dispatches the load queue. Takes a unit from the queue and
60918275
LP		 1286 * tries to load its data until the queue is empty */
1287
595ed347
MS		 1288 while ((u = m->load_queue)) {
1289 assert(u->in_load_queue);
034c6ed7 1290
595ed347 1291 unit_load(u);
c1e1601e 1292 n++;
60918275
LP		 1293 }
1294
223dabab 1295 m->dispatching_load_queue = false;
c1e1601e 1296 return n;
60918275
LP		 1297}
1298
c2756a68
LP		 1299int manager_load_unit_prepare(
1300 Manager *m,
1301 const char *name,
1302 const char *path,
718db961 1303 sd_bus_error *e,
c2756a68
LP		 1304 Unit **_ret) {
1305
87f0e418 1306 Unit *ret;
7d17cfbc 1307 UnitType t;
60918275
LP		 1308 int r;
1309
1310 assert(m);
9e2f7c11 1311 assert(name || path);
60918275 1312
db06e3b6
LP		 1313 /* This will prepare the unit for loading, but not actually
1314 * load anything from disk. */
0301abf4 1315
718db961
LP		 1316 if (path && !is_path(path))
1317 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
9e2f7c11
LP		 1318
1319 if (!name)
2b6bf07d 1320 name = basename(path);
9e2f7c11 1321
7d17cfbc
MS		 1322 t = unit_name_to_type(name);
1323
f78e6385 1324 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
718db961 1325 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
60918275 1326
7d17cfbc
MS		 1327 ret = manager_get_unit(m, name);
1328 if (ret) {
034c6ed7 1329 *_ret = ret;
413d6313 1330 return 1;
034c6ed7 1331 }
60918275 1332
7d17cfbc
MS		 1333 ret = unit_new(m, unit_vtable[t]->object_size);
1334 if (!ret)
60918275
LP		 1335 return -ENOMEM;
1336
7d17cfbc 1337 if (path) {
ac155bb8
MS		 1338 ret->fragment_path = strdup(path);
1339 if (!ret->fragment_path) {
0301abf4
LP		 1340 unit_free(ret);
1341 return -ENOMEM;
1342 }
7d17cfbc 1343 }
0301abf4 1344
1058cbf2
ZJS		 1345 r = unit_add_name(ret, name);
1346 if (r < 0) {
87f0e418 1347 unit_free(ret);
1ffba6fe 1348 return r;
60918275
LP		 1349 }
1350
87f0e418 1351 unit_add_to_load_queue(ret);
c1e1601e 1352 unit_add_to_dbus_queue(ret);
949061f0 1353 unit_add_to_gc_queue(ret);
c1e1601e 1354
db06e3b6
LP		 1355 if (_ret)
1356 *_ret = ret;
1357
1358 return 0;
1359}
1360
c2756a68
LP		 1361int manager_load_unit(
1362 Manager *m,
1363 const char *name,
1364 const char *path,
718db961 1365 sd_bus_error *e,
c2756a68
LP		 1366 Unit **_ret) {
1367
db06e3b6
LP		 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
c3090674
LP		 1375 r = manager_load_unit_prepare(m, name, path, e, _ret);
1376 if (r != 0)
db06e3b6
LP		 1377 return r;
1378
f50e0a01 1379 manager_dispatch_load_queue(m);
60918275 1380
9e2f7c11 1381 if (_ret)
413d6313 1382 *_ret = unit_follow_merge(*_ret);
9e2f7c11 1383
60918275
LP		 1384 return 0;
1385}
a66d02c3 1386
cea8e32e 1387void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
034c6ed7 1388 Iterator i;
a66d02c3
LP		 1389 Job *j;
1390
1391 assert(s);
1392 assert(f);
1393
034c6ed7 1394 HASHMAP_FOREACH(j, s->jobs, i)
cea8e32e 1395 job_dump(j, f, prefix);
a66d02c3
LP		 1396}
1397
87f0e418 1398void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
034c6ed7 1399 Iterator i;
87f0e418 1400 Unit *u;
11dd41ce 1401 const char *t;
a66d02c3
LP		 1402
1403 assert(s);
1404 assert(f);
1405
87f0e418 1406 HASHMAP_FOREACH_KEY(u, t, s->units, i)
ac155bb8 1407 if (u->id == t)
87f0e418 1408 unit_dump(u, f, prefix);
a66d02c3 1409}
7fad411c
LP		 1410
1411void manager_clear_jobs(Manager *m) {
1412 Job *j;
1413
1414 assert(m);
1415
7fad411c 1416 while ((j = hashmap_first(m->jobs)))
5273510e
MS		 1417 /* No need to recurse. We're cancelling all jobs. */
1418 job_finish_and_invalidate(j, JOB_CANCELED, false);
7fad411c 1419}
83c60c9f 1420
752b5905
LP		 1421static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1422 Manager *m = userdata;
83c60c9f 1423 Job *j;
034c6ed7 1424
752b5905
LP		 1425 assert(source);
1426 assert(m);
9152c765 1427
034c6ed7 1428 while ((j = m->run_queue)) {
ac1135be 1429 assert(j->installed);
034c6ed7
LP		 1430 assert(j->in_run_queue);
1431
1432 job_run_and_invalidate(j);
9152c765 1433 }
034c6ed7 1434
a0b64226 1435 if (m->n_running_jobs > 0)
03b717a3
MS		 1436 manager_watch_jobs_in_progress(m);
1437
31a7eb86
ZJS		 1438 if (m->n_on_console > 0)
1439 manager_watch_idle_pipe(m);
1440
752b5905 1441 return 1;
c1e1601e
LP		 1442}
1443
9588bc32 1444static unsigned manager_dispatch_dbus_queue(Manager *m) {
c1e1601e 1445 Job *j;
595ed347 1446 Unit *u;
c1e1601e
LP		 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
595ed347
MS		 1456 while ((u = m->dbus_unit_queue)) {
1457 assert(u->in_dbus_queue);
c1e1601e 1458
595ed347 1459 bus_unit_send_change_signal(u);
c1e1601e
LP		 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;
71445ae7
LP		 1471
1472 if (m->send_reloading_done) {
1473 m->send_reloading_done = false;
1474
718db961 1475 bus_manager_send_reloading(m, false);
71445ae7
LP		 1476 }
1477
718db961
LP		 1478 if (m->queued_message)
1479 bus_send_queued_message(m);
1480
c1e1601e 1481 return n;
9152c765
LP		 1482}
1483
5ba6985b
LP		 1484static 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
718db961
LP		 1504static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1505 Manager *m = userdata;
8c47c732
LP		 1506 ssize_t n;
1507
1508 assert(m);
718db961
LP		 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 }
8c47c732
LP		 1515
1516 for (;;) {
1517 char buf[4096];
b92bea5d
ZJS		 1518 struct iovec iovec = {
1519 .iov_base = buf,
1520 .iov_len = sizeof(buf)-1,
1521 };
5ba6985b 1522 bool found = false;
b92bea5d 1523
8c47c732
LP		 1524 union {
1525 struct cmsghdr cmsghdr;
1526 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
b92bea5d
ZJS		 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;
70af4d17 1536 Unit *u1, *u2, *u3;
8c47c732 1537
718db961 1538 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
bd0af849 1539 if (n <= 0) {
b92bea5d 1540 if (n == 0)
8c47c732
LP		 1541 return -EIO;
1542
f6144808 1543 if (errno == EAGAIN || errno == EINTR)
8c47c732
LP		 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
8c40acf7
LP		 1559 assert((size_t) n < sizeof(buf));
1560 buf[n] = 0;
8c47c732 1561
70af4d17
LP		 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);
5ba6985b
LP		 1567 found = true;
1568 }
1569
70af4d17
LP		 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);
5ba6985b
LP		 1573 found = true;
1574 }
1575
70af4d17
LP		 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);
5ba6985b
LP		 1579 found = true;
1580 }
8c47c732 1581
5ba6985b
LP		 1582 if (!found)
1583 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
8c47c732
LP		 1584 }
1585
1586 return 0;
1587}
1588
5ba6985b
LP		 1589static 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
034c6ed7 1600static int manager_dispatch_sigchld(Manager *m) {
9152c765
LP		 1601 assert(m);
1602
1603 for (;;) {
b92bea5d 1604 siginfo_t si = {};
9152c765 1605
4112df16
LP		 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) {
acbb0225
LP		 1610
1611 if (errno == ECHILD)
1612 break;
1613
4112df16
LP		 1614 if (errno == EINTR)
1615 continue;
1616
9152c765 1617 return -errno;
acbb0225 1618 }
9152c765 1619
4112df16 1620 if (si.si_pid <= 0)
9152c765
LP		 1621 break;
1622
15d5d9d9 1623 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
7fd1b19b 1624 _cleanup_free_ char *name = NULL;
70af4d17 1625 Unit *u1, *u2, *u3;
4112df16 1626
87d2c1ff 1627 get_process_comm(si.si_pid, &name);
4112df16 1628
5ba6985b
LP		 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... */
70af4d17
LP		 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);
5ba6985b 1648 }
8c47c732 1649
4112df16
LP		 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 }
9152c765
LP		 1657 }
1658
1659 return 0;
1660}
1661
7d793605 1662static int manager_start_target(Manager *m, const char *name, JobMode mode) {
718db961 1663 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
28247076 1664 int r;
398ef8ba 1665
66870f90 1666 log_debug_unit(name, "Activating special unit %s", name);
1e001f52 1667
bd0af849
ZJS		 1668 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1669 if (r < 0)
718db961 1670 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
a1b256b0
LP		 1671
1672 return r;
28247076
LP		 1673}
1674
718db961
LP		 1675static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1676 Manager *m = userdata;
9152c765
LP		 1677 ssize_t n;
1678 struct signalfd_siginfo sfsi;
1679 bool sigchld = false;
1680
1681 assert(m);
718db961
LP		 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 }
9152c765
LP		 1688
1689 for (;;) {
718db961 1690 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
57cb4adf 1691 if (n != sizeof(sfsi)) {
9152c765
LP		 1692
1693 if (n >= 0)
1694 return -EIO;
1695
63090775 1696 if (errno == EINTR || errno == EAGAIN)
acbb0225 1697 break;
9152c765
LP		 1698
1699 return -errno;
1700 }
1701
4daf54a8
ZJS		 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);
1e001f52 1706
b9cd2ec1
LP		 1707 switch (sfsi.ssi_signo) {
1708
4112df16 1709 case SIGCHLD:
9152c765 1710 sigchld = true;
b9cd2ec1
LP		 1711 break;
1712
6632c602 1713 case SIGTERM:
67445f4e 1714 if (m->running_as == SYSTEMD_SYSTEM) {
db06e3b6
LP		 1715 /* This is for compatibility with the
1716 * original sysvinit */
e11dc4a2 1717 m->exit_code = MANAGER_REEXECUTE;
a1b256b0
LP		 1718 break;
1719 }
84e9af1e 1720
a1b256b0 1721 /* Fall through */
e11dc4a2
LP		 1722
1723 case SIGINT:
67445f4e 1724 if (m->running_as == SYSTEMD_SYSTEM) {
f49fd1d5 1725 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
84e9af1e
LP		 1726 break;
1727 }
1728
a1b256b0 1729 /* Run the exit target if there is one, if not, just exit. */
0003d1ab 1730 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
a1b256b0
LP		 1731 m->exit_code = MANAGER_EXIT;
1732 return 0;
1733 }
1734
1735 break;
84e9af1e 1736
28247076 1737 case SIGWINCH:
67445f4e 1738 if (m->running_as == SYSTEMD_SYSTEM)
7d793605 1739 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
84e9af1e 1740
28247076
LP		 1741 /* This is a nop on non-init */
1742 break;
84e9af1e 1743
28247076 1744 case SIGPWR:
67445f4e 1745 if (m->running_as == SYSTEMD_SYSTEM)
7d793605 1746 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
84e9af1e 1747
28247076 1748 /* This is a nop on non-init */
84e9af1e 1749 break;
6632c602 1750
1005d14f 1751 case SIGUSR1: {
57ee42ce
LP		 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...");
3996fbe2 1758 bus_init(m, true);
57ee42ce
LP		 1759 }
1760
1761 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1762 log_info("Loading D-Bus service...");
7d793605 1763 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
57ee42ce
LP		 1764 }
1765
1766 break;
1767 }
1768
2149e37c 1769 case SIGUSR2: {
718db961
LP		 1770 _cleanup_free_ char *dump = NULL;
1771 _cleanup_fclose_ FILE *f = NULL;
2149e37c
LP		 1772 size_t size;
1773
718db961
LP		 1774 f = open_memstream(&dump, &size);
1775 if (!f) {
2149e37c
LP		 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)) {
2149e37c
LP		 1784 log_warning("Failed to write status stream");
1785 break;
1786 }
1787
b2cdc666
DM		 1788 if (fflush(f)) {
1789 log_warning("Failed to flush status stream");
1790 break;
1791 }
1792
2149e37c 1793 log_dump(LOG_INFO, dump);
1005d14f 1794 break;
2149e37c 1795 }
1005d14f 1796
a16e1123
LP		 1797 case SIGHUP:
1798 m->exit_code = MANAGER_RELOAD;
1799 break;
1800
7d793605 1801 default: {
253ee27a 1802
0003d1ab
LP		 1803 /* Starting SIGRTMIN+0 */
1804 static const char * const target_table[] = {
7d793605
LP		 1805 [0] = SPECIAL_DEFAULT_TARGET,
1806 [1] = SPECIAL_RESCUE_TARGET,
f057408c 1807 [2] = SPECIAL_EMERGENCY_TARGET,
7d793605
LP		 1808 [3] = SPECIAL_HALT_TARGET,
1809 [4] = SPECIAL_POWEROFF_TARGET,
0003d1ab
LP		 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
7d793605
LP		 1820 };
1821
1822 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
0003d1ab 1823 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
764e9b5f
MS		 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);
7d793605
LP		 1827 break;
1828 }
1829
0003d1ab
LP		 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
0658666b
LP		 1836 switch (sfsi.ssi_signo - SIGRTMIN) {
1837
1838 case 20:
1839 log_debug("Enabling showing of status.");
d450b6f2 1840 manager_set_show_status(m, SHOW_STATUS_YES);
0658666b
LP		 1841 break;
1842
1843 case 21:
1844 log_debug("Disabling showing of status.");
d450b6f2 1845 manager_set_show_status(m, SHOW_STATUS_NO);
0658666b
LP		 1846 break;
1847
253ee27a
LP		 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
600b704e
LP		 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
4cfa2c99 1867 case 26:
c1dc6153 1868 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
4cfa2c99
LP		 1869 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1870 log_notice("Setting log target to journal-or-kmsg.");
1871 break;
1872
253ee27a
LP		 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
0658666b 1883 default:
4e240ab0 1884 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
0658666b 1885 }
b9cd2ec1 1886 }
7d793605 1887 }
9152c765
LP		 1888 }
1889
1890 if (sigchld)
7b77ed8c 1891 manager_dispatch_sigchld(m);
034c6ed7
LP		 1892
1893 return 0;
1894}
1895
718db961
LP		 1896static 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;
034c6ed7
LP		 1900
1901 assert(m);
718db961 1902 assert(m->time_change_fd == fd);
034c6ed7 1903
718db961
LP		 1904 log_struct(LOG_INFO,
1905 MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1906 "MESSAGE=Time has been changed",
1907 NULL);
034c6ed7 1908
718db961
LP		 1909 /* Restart the watch */
1910 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
03e334a1 1911 m->time_change_fd = safe_close(m->time_change_fd);
ef734fd6 1912
718db961 1913 manager_setup_time_change(m);
4e434314 1914
718db961
LP		 1915 HASHMAP_FOREACH(u, m->units, i)
1916 if (UNIT_VTABLE(u)->time_change)
1917 UNIT_VTABLE(u)->time_change(u);
ea430986 1918
718db961
LP		 1919 return 0;
1920}
ea430986 1921
718db961
LP		 1922static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1923 Manager *m = userdata;
8742514c 1924
718db961
LP		 1925 assert(m);
1926 assert(m->idle_pipe[2] == fd);
8742514c 1927
718db961 1928 m->no_console_output = m->n_on_console > 0;
03b717a3 1929
718db961
LP		 1930 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1931 manager_close_idle_pipe(m);
03b717a3 1932
718db961
LP		 1933 return 0;
1934}
31a7eb86 1935
718db961
LP		 1936static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1937 Manager *m = userdata;
fd08a840
ZJS		 1938 int r;
1939 uint64_t next;
31a7eb86 1940
718db961 1941 assert(m);
fd08a840 1942 assert(source);
9152c765 1943
718db961 1944 manager_print_jobs_in_progress(m);
fd08a840
ZJS		 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);
9152c765
LP		 1952}
1953
1954int manager_loop(Manager *m) {
1955 int r;
9152c765 1956
fac9f8df 1957 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
ea430986 1958
9152c765 1959 assert(m);
f755e3b7 1960 m->exit_code = MANAGER_OK;
9152c765 1961
fe51822e
LP		 1962 /* Release the path cache */
1963 set_free_free(m->unit_path_cache);
1964 m->unit_path_cache = NULL;
1965
b0c918b9
LP		 1966 manager_check_finished(m);
1967
a4312405 1968 /* There might still be some zombies hanging around from
f3669545 1969 * before we were exec()'ed. Let's reap them. */
e96d6be7
LP		 1970 r = manager_dispatch_sigchld(m);
1971 if (r < 0)
a4312405
LP		 1972 return r;
1973
f755e3b7 1974 while (m->exit_code == MANAGER_OK) {
718db961 1975 usec_t wait_usec;
9152c765 1976
67445f4e 1977 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
e96d6be7
LP		 1978 watchdog_ping();
1979
ea430986
LP		 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);
e96d6be7 1984 continue;
ea430986
LP		 1985 }
1986
37a8e683 1987 if (manager_dispatch_load_queue(m) > 0)
23a177ef
LP		 1988 continue;
1989
cf1265e1 1990 if (manager_dispatch_gc_queue(m) > 0)
701cc384
LP		 1991 continue;
1992
cf1265e1 1993 if (manager_dispatch_cleanup_queue(m) > 0)
c1e1601e 1994 continue;
034c6ed7 1995
cf1265e1 1996 if (manager_dispatch_cgroup_queue(m) > 0)
c1e1601e
LP		 1997 continue;
1998
c1e1601e 1999 if (manager_dispatch_dbus_queue(m) > 0)
ea430986 2000 continue;
ea430986 2001
c757a65b 2002 /* Sleep for half the watchdog time */
67445f4e 2003 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
718db961
LP		 2004 wait_usec = m->runtime_watchdog / 2;
2005 if (wait_usec <= 0)
2006 wait_usec = 1;
c757a65b 2007 } else
3a43da28 2008 wait_usec = USEC_INFINITY;
9152c765 2009
718db961
LP		 2010 r = sd_event_run(m->event, wait_usec);
2011 if (r < 0) {
2012 log_error("Failed to run event loop: %s", strerror(-r));
957ca890 2013 return r;
718db961 2014 }
a16e1123 2015 }
957ca890 2016
a16e1123 2017 return m->exit_code;
83c60c9f 2018}
ea430986 2019
718db961 2020int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
ede3a796 2021 _cleanup_free_ char *n = NULL;
ea430986 2022 Unit *u;
80fbf05e 2023 int r;
ea430986
LP		 2024
2025 assert(m);
2026 assert(s);
2027 assert(_u);
2028
ede3a796
LP		 2029 r = unit_name_from_dbus_path(s, &n);
2030 if (r < 0)
2031 return r;
ea430986 2032
80fbf05e 2033 r = manager_load_unit(m, n, NULL, e, &u);
80fbf05e
MS		 2034 if (r < 0)
2035 return r;
ea430986
LP		 2036
2037 *_u = u;
2038
2039 return 0;
2040}
86fbf370
LP		 2041
2042int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
718db961 2043 const char *p;
86fbf370 2044 unsigned id;
718db961 2045 Job *j;
86fbf370
LP		 2046 int r;
2047
2048 assert(m);
2049 assert(s);
2050 assert(_j);
2051
718db961
LP		 2052 p = startswith(s, "/org/freedesktop/systemd1/job/");
2053 if (!p)
86fbf370
LP		 2054 return -EINVAL;
2055
718db961 2056 r = safe_atou(p, &id);
8742514c 2057 if (r < 0)
86fbf370
LP		 2058 return r;
2059
8742514c
LP		 2060 j = manager_get_job(m, id);
2061 if (!j)
86fbf370
LP		 2062 return -ENOENT;
2063
2064 *_j = j;
2065
2066 return 0;
2067}
dfcd764e 2068
4927fcae 2069void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
e537352b 2070
4927fcae 2071#ifdef HAVE_AUDIT
2ba11090 2072 _cleanup_free_ char *p = NULL;
c1165f82 2073 int audit_fd;
e537352b 2074
c1165f82
LP		 2075 audit_fd = get_audit_fd();
2076 if (audit_fd < 0)
e537352b
LP		 2077 return;
2078
bbd3a7ba
LP		 2079 /* Don't generate audit events if the service was already
2080 * started and we're just deserializing */
a7556052 2081 if (m->n_reloading > 0)
bbd3a7ba
LP		 2082 return;
2083
67445f4e 2084 if (m->running_as != SYSTEMD_SYSTEM)
f1dd0c3f
LP		 2085 return;
2086
ac155bb8 2087 if (u->type != UNIT_SERVICE)
f1dd0c3f
LP		 2088 return;
2089
bd0af849
ZJS		 2090 p = unit_name_to_prefix_and_instance(u->id);
2091 if (!p) {
66870f90
ZJS		 2092 log_error_unit(u->id,
2093 "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
e537352b
LP		 2094 return;
2095 }
2096
c1165f82 2097 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
391ade86
LP		 2098 if (errno == EPERM) {
2099 /* We aren't allowed to send audit messages?
44785992 2100 * Then let's not retry again. */
c1165f82 2101 close_audit_fd();
44785992
LP		 2102 } else
2103 log_warning("Failed to send audit message: %m");
391ade86 2104 }
4927fcae 2105#endif
e537352b 2106
e537352b
LP		 2107}
2108
e983b760 2109void manager_send_unit_plymouth(Manager *m, Unit *u) {
1d749d04 2110 union sockaddr_union sa = PLYMOUTH_SOCKET;
2ba11090 2111
e983b760 2112 int n = 0;
2ba11090
ZJS		 2113 _cleanup_free_ char *message = NULL;
2114 _cleanup_close_ int fd = -1;
e983b760
LP		 2115
2116 /* Don't generate plymouth events if the service was already
2117 * started and we're just deserializing */
a7556052 2118 if (m->n_reloading > 0)
e983b760
LP		 2119 return;
2120
67445f4e 2121 if (m->running_as != SYSTEMD_SYSTEM)
e983b760
LP		 2122 return;
2123
3772995a
LP		 2124 if (detect_container(NULL) > 0)
2125 return;
2126
ac155bb8
MS		 2127 if (u->type != UNIT_SERVICE &&
2128 u->type != UNIT_MOUNT &&
2129 u->type != UNIT_SWAP)
e983b760
LP		 2130 return;
2131
2132 /* We set SOCK_NONBLOCK here so that we rather drop the
2133 * message then wait for plymouth */
e62d8c39
ZJS		 2134 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2135 if (fd < 0) {
e983b760
LP		 2136 log_error("socket() failed: %m");
2137 return;
2138 }
2139
96707269 2140 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
e983b760 2141
2ba11090 2142 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
e983b760 2143 log_error("connect() failed: %m");
2ba11090 2144 return;
e983b760
LP		 2145 }
2146
ac155bb8 2147 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
0d0f0c50 2148 log_oom();
2ba11090 2149 return;
e983b760
LP		 2150 }
2151
2152 errno = 0;
2ba11090
ZJS		 2153 if (write(fd, message, n + 1) != n + 1)
2154 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
e983b760 2155 log_error("Failed to write Plymouth message: %m");
e983b760
LP		 2156}
2157
05e343b7
LP		 2158void manager_dispatch_bus_name_owner_changed(
2159 Manager *m,
2160 const char *name,
2161 const char* old_owner,
2162 const char *new_owner) {
2163
2164 Unit *u;
2165
2166 assert(m);
2167 assert(name);
2168
718db961
LP		 2169 u = hashmap_get(m->watch_bus, name);
2170 if (!u)
05e343b7
LP		 2171 return;
2172
2173 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2174}
2175
d8d5ab98 2176int manager_open_serialization(Manager *m, FILE **_f) {
8e33886e 2177 const char *path;
df28bc08 2178 int fd = -1;
a16e1123
LP		 2179 FILE *f;
2180
2181 assert(_f);
2182
8e33886e
ZJS		 2183 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2184 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
d86f9d52 2185 if (fd < 0)
a16e1123 2186 return -errno;
a16e1123 2187
a16e1123 2188 log_debug("Serializing state to %s", path);
a16e1123 2189
01e10de3 2190 f = fdopen(fd, "w+");
d86f9d52 2191 if (!f) {
03e334a1 2192 safe_close(fd);
a16e1123 2193 return -errno;
d86f9d52 2194 }
a16e1123
LP		 2195
2196 *_f = f;
2197
2198 return 0;
2199}
2200
b3680f49 2201int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
a16e1123
LP		 2202 Iterator i;
2203 Unit *u;
2204 const char *t;
4a9fd066 2205 char **e;
a16e1123
LP		 2206 int r;
2207
2208 assert(m);
2209 assert(f);
2210 assert(fds);
2211
a7556052 2212 m->n_reloading ++;
38c52d46 2213
01d67b43
LP		 2214 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2215 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
33c5fae9
LP		 2216 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2217 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
01d67b43 2218
915b3753 2219 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
915b3753 2220 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
718db961 2221 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
e9ddabc2 2222 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
f38ed060 2223
26a1efdf 2224 if (!in_initrd()) {
915b3753 2225 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
f38ed060 2226 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
718db961
LP		 2227 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2228 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2229 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2230 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2231 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2232 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
f38ed060 2233 }
47a483a1 2234
b3680f49
HH		 2235 if (!switching_root) {
2236 STRV_FOREACH(e, m->environment) {
2237 _cleanup_free_ char *ce;
4a9fd066 2238
b3680f49 2239 ce = cescape(*e);
e3dd987c
LP		 2240 if (!ce)
2241 return -ENOMEM;
2242
2243 fprintf(f, "env=%s\n", *e);
b3680f49 2244 }
4a9fd066
OS		 2245 }
2246
d86f9d52
LP		 2247 if (m->notify_fd >= 0) {
2248 int copy;
2249
2250 copy = fdset_put_dup(fds, m->notify_fd);
2251 if (copy < 0)
2252 return copy;
2253
2254 fprintf(f, "notify-fd=%i\n", copy);
2255 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2256 }
2257
e3dd987c
LP		 2258 if (m->kdbus_fd >= 0) {
2259 int copy;
2260
2261 copy = fdset_put_dup(fds, m->kdbus_fd);
2262 if (copy < 0)
2263 return copy;
2264
2265 fprintf(f, "kdbus-fd=%i\n", copy);
2266 }
2267
8f8f05a9 2268 bus_track_serialize(m->subscribed, f);
6fa48533 2269
f2382a94
LP		 2270 fputc('\n', f);
2271
a16e1123 2272 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
ac155bb8 2273 if (u->id != t)
a16e1123
LP		 2274 continue;
2275
a16e1123 2276 /* Start marker */
ac155bb8 2277 fputs(u->id, f);
a16e1123
LP		 2278 fputc('\n', f);
2279
6fa48533
LP		 2280 r = unit_serialize(u, f, fds, !switching_root);
2281 if (r < 0) {
a7556052 2282 m->n_reloading --;
a16e1123 2283 return r;
38c52d46 2284 }
a16e1123
LP		 2285 }
2286
a7556052
LP		 2287 assert(m->n_reloading > 0);
2288 m->n_reloading --;
38c52d46 2289
a16e1123
LP		 2290 if (ferror(f))
2291 return -EIO;
2292
b23de6af
LP		 2293 r = bus_fdset_add_all(m, fds);
2294 if (r < 0)
2295 return r;
2296
a16e1123
LP		 2297 return 0;
2298}
2299
2300int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2301 int r = 0;
2302
2303 assert(m);
2304 assert(f);
2305
2306 log_debug("Deserializing state...");
2307
a7556052 2308 m->n_reloading ++;
82c64bf5 2309
10f8e83c 2310 for (;;) {
20c03b7b 2311 char line[LINE_MAX], *l;
10f8e83c
LP		 2312
2313 if (!fgets(line, sizeof(line), f)) {
2314 if (feof(f))
2315 r = 0;
2316 else
2317 r = -errno;
2318
2319 goto finish;
2320 }
2321
2322 char_array_0(line);
2323 l = strstrip(line);
2324
2325 if (l[0] == 0)
2326 break;
2327
01d67b43
LP		 2328 if (startswith(l, "current-job-id=")) {
2329 uint32_t id;
2330
2331 if (safe_atou32(l+15, &id) < 0)
46849c3f 2332 log_warning("Failed to parse current job id value %s", l+15);
01d67b43
LP		 2333 else
2334 m->current_job_id = MAX(m->current_job_id, id);
718db961 2335
33c5fae9
LP		 2336 } else if (startswith(l, "n-installed-jobs=")) {
2337 uint32_t n;
2338
2339 if (safe_atou32(l+17, &n) < 0)
46849c3f 2340 log_warning("Failed to parse installed jobs counter %s", l+17);
33c5fae9
LP		 2341 else
2342 m->n_installed_jobs += n;
718db961 2343
33c5fae9
LP		 2344 } else if (startswith(l, "n-failed-jobs=")) {
2345 uint32_t n;
2346
2347 if (safe_atou32(l+14, &n) < 0)
46849c3f 2348 log_warning("Failed to parse failed jobs counter %s", l+14);
33c5fae9
LP		 2349 else
2350 m->n_failed_jobs += n;
718db961 2351
01d67b43
LP		 2352 } else if (startswith(l, "taint-usr=")) {
2353 int b;
2354
e3dd987c
LP		 2355 b = parse_boolean(l+10);
2356 if (b < 0)
46849c3f 2357 log_warning("Failed to parse taint /usr flag %s", l+10);
01d67b43
LP		 2358 else
2359 m->taint_usr = m->taint_usr || b;
718db961 2360
915b3753
LP		 2361 } else if (startswith(l, "firmware-timestamp="))
2362 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2363 else if (startswith(l, "loader-timestamp="))
2364 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2365 else if (startswith(l, "kernel-timestamp="))
2366 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2367 else if (startswith(l, "initrd-timestamp="))
e9ddabc2 2368 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
915b3753
LP		 2369 else if (startswith(l, "userspace-timestamp="))
2370 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
10717a1a 2371 else if (startswith(l, "finish-timestamp="))
799fd0fd 2372 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
718db961
LP		 2373 else if (startswith(l, "security-start-timestamp="))
2374 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2375 else if (startswith(l, "security-finish-timestamp="))
2376 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2377 else if (startswith(l, "generators-start-timestamp="))
2378 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2379 else if (startswith(l, "generators-finish-timestamp="))
2380 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2381 else if (startswith(l, "units-load-start-timestamp="))
2382 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2383 else if (startswith(l, "units-load-finish-timestamp="))
2384 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
4a9fd066
OS		 2385 else if (startswith(l, "env=")) {
2386 _cleanup_free_ char *uce = NULL;
2387 char **e;
2388
2389 uce = cunescape(l+4);
2390 if (!uce) {
2391 r = -ENOMEM;
2392 goto finish;
2393 }
2394
2395 e = strv_env_set(m->environment, uce);
2396 if (!e) {
2397 r = -ENOMEM;
2398 goto finish;
2399 }
2400
2401 strv_free(m->environment);
2402 m->environment = e;
e3dd987c 2403
d86f9d52
LP		 2404 } else if (startswith(l, "notify-fd=")) {
2405 int fd;
2406
2407 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
46849c3f 2408 log_warning("Failed to parse notify fd: %s", l + 10);
d86f9d52 2409 else {
03e334a1
LP		 2410 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2411 safe_close(m->notify_fd);
d86f9d52
LP		 2412 m->notify_fd = fdset_remove(fds, fd);
2413 }
2414
2415 } else if (startswith(l, "notify-socket=")) {
2416 char *n;
2417
2418 n = strdup(l+14);
2419 if (!n) {
2420 r = -ENOMEM;
2421 goto finish;
2422 }
2423
2424 free(m->notify_socket);
2425 m->notify_socket = n;
2426
e3dd987c
LP		 2427 } else if (startswith(l, "kdbus-fd=")) {
2428 int fd;
2429
8bf9fcf4 2430 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
46849c3f 2431 log_warning("Failed to parse kdbus fd: %s", l + 9);
e3dd987c 2432 else {
03e334a1 2433 safe_close(m->kdbus_fd);
e3dd987c
LP		 2434 m->kdbus_fd = fdset_remove(fds, fd);
2435 }
2436
8f8f05a9 2437 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
46849c3f 2438 log_warning("Unknown serialization item '%s'", l);
10f8e83c
LP		 2439 }
2440
a16e1123
LP		 2441 for (;;) {
2442 Unit *u;
2443 char name[UNIT_NAME_MAX+2];
2444
2445 /* Start marker */
2446 if (!fgets(name, sizeof(name), f)) {
2447 if (feof(f))
10f8e83c
LP		 2448 r = 0;
2449 else
2450 r = -errno;
a16e1123 2451
82c64bf5 2452 goto finish;
a16e1123
LP		 2453 }
2454
2455 char_array_0(name);
2456
bd0af849
ZJS		 2457 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2458 if (r < 0)
82c64bf5 2459 goto finish;
a16e1123 2460
01e10de3
LP		 2461 r = unit_deserialize(u, f, fds);
2462 if (r < 0)
82c64bf5 2463 goto finish;
a16e1123
LP		 2464 }
2465
10f8e83c 2466finish:
145b1f79 2467 if (ferror(f))
82c64bf5 2468 r = -EIO;
a16e1123 2469
a7556052
LP		 2470 assert(m->n_reloading > 0);
2471 m->n_reloading --;
82c64bf5
LP		 2472
2473 return r;
a16e1123
LP		 2474}
2475
2476int manager_reload(Manager *m) {
2477 int r, q;
51d122af
ZJS		 2478 _cleanup_fclose_ FILE *f = NULL;
2479 _cleanup_fdset_free_ FDSet *fds = NULL;
a16e1123
LP		 2480
2481 assert(m);
2482
07719a21
LP		 2483 r = manager_open_serialization(m, &f);
2484 if (r < 0)
a16e1123
LP		 2485 return r;
2486
a7556052 2487 m->n_reloading ++;
718db961 2488 bus_manager_send_reloading(m, true);
38c52d46 2489
07719a21
LP		 2490 fds = fdset_new();
2491 if (!fds) {
a7556052 2492 m->n_reloading --;
51d122af 2493 return -ENOMEM;
a16e1123
LP		 2494 }
2495
b3680f49 2496 r = manager_serialize(m, f, fds, false);
07719a21 2497 if (r < 0) {
a7556052 2498 m->n_reloading --;
51d122af 2499 return r;
38c52d46 2500 }
a16e1123
LP		 2501
2502 if (fseeko(f, 0, SEEK_SET) < 0) {
a7556052 2503 m->n_reloading --;
51d122af 2504 return -errno;
a16e1123
LP		 2505 }
2506
2507 /* From here on there is no way back. */
2508 manager_clear_jobs_and_units(m);
5a1e9937 2509 manager_undo_generators(m);
84e3543e 2510 lookup_paths_free(&m->lookup_paths);
2ded0c04 2511
07719a21 2512 /* Find new unit paths */
5a1e9937
LP		 2513 manager_run_generators(m);
2514
07719a21
LP		 2515 q = lookup_paths_init(
2516 &m->lookup_paths, m->running_as, true,
12ed81d9 2517 NULL,
07719a21
LP		 2518 m->generator_unit_path,
2519 m->generator_unit_path_early,
2520 m->generator_unit_path_late);
2521 if (q < 0)
2522 r = q;
2523
5a1e9937
LP		 2524 manager_build_unit_path_cache(m);
2525
a16e1123 2526 /* First, enumerate what we can from all config files */
07719a21
LP		 2527 q = manager_enumerate(m);
2528 if (q < 0)
a16e1123
LP		 2529 r = q;
2530
2531 /* Second, deserialize our stored data */
07719a21
LP		 2532 q = manager_deserialize(m, f, fds);
2533 if (q < 0)
a16e1123
LP		 2534 r = q;
2535
2536 fclose(f);
2537 f = NULL;
2538
a2cc4a6c
ZJS		 2539 /* Re-register notify_fd as event source */
2540 q = manager_setup_notify(m);
2541 if (q < 0)
2542 r = q;
2543
a16e1123 2544 /* Third, fire things up! */
07719a21
LP		 2545 q = manager_coldplug(m);
2546 if (q < 0)
a16e1123
LP		 2547 r = q;
2548
a7556052
LP		 2549 assert(m->n_reloading > 0);
2550 m->n_reloading--;
9f611ad8 2551
71445ae7
LP		 2552 m->send_reloading_done = true;
2553
a16e1123
LP		 2554 return r;
2555}
2556
c17ec25e
MS		 2557bool manager_is_reloading_or_reexecuting(Manager *m) {
2558 assert(m);
2559
2560 return m->n_reloading != 0;
2561}
2562
fdf20a31 2563void manager_reset_failed(Manager *m) {
5632e374
LP		 2564 Unit *u;
2565 Iterator i;
2566
2567 assert(m);
2568
2569 HASHMAP_FOREACH(u, m->units, i)
fdf20a31 2570 unit_reset_failed(u);
5632e374
LP		 2571}
2572
31afa0a4 2573bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
8f6df3fa
LP		 2574 Unit *u;
2575
2576 assert(m);
2577 assert(name);
2578
2579 /* Returns true if the unit is inactive or going down */
bd0af849
ZJS		 2580 u = manager_get_unit(m, name);
2581 if (!u)
8f6df3fa
LP		 2582 return true;
2583
31afa0a4 2584 return unit_inactive_or_pending(u);
8f6df3fa
LP		 2585}
2586
b0c918b9 2587void manager_check_finished(Manager *m) {
7ceba241 2588 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
915b3753 2589 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
95ae05c0
WC		 2590 Unit *u = NULL;
2591 Iterator i;
b0c918b9
LP		 2592
2593 assert(m);
2594
a0b64226 2595 if (m->n_running_jobs == 0)
718db961 2596 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
a0b64226 2597
828db5d8 2598 if (hashmap_size(m->jobs) > 0) {
f755e3b7 2599
2928b0a8
LP		 2600 if (m->jobs_in_progress_event_source)
2601 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
f755e3b7 2602
b0c918b9 2603 return;
5b176ee0 2604 }
b0c918b9 2605
cb8ccb22 2606 manager_flip_auto_status(m, false);
d450b6f2 2607
f2b68789 2608 /* Notify Type=idle units that we are done now */
718db961
LP		 2609 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2610 manager_close_idle_pipe(m);
f2b68789 2611
af6da548
LP		 2612 /* Turn off confirm spawn now */
2613 m->confirm_spawn = false;
2614
e46b13c8
ZJS		 2615 /* No need to update ask password status when we're going non-interactive */
2616 manager_close_ask_password(m);
2617
418b9be5 2618 /* This is no longer the first boot */
e2680723 2619 manager_set_first_boot(m, false);
418b9be5 2620
f2b68789 2621 if (dual_timestamp_is_set(&m->finish_timestamp))
b0c918b9
LP		 2622 return;
2623
2624 dual_timestamp_get(&m->finish_timestamp);
2625
67445f4e 2626 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
e03ae661 2627
915b3753
LP		 2628 /* Note that m->kernel_usec.monotonic is always at 0,
2629 * and m->firmware_usec.monotonic and
2630 * m->loader_usec.monotonic should be considered
2631 * negative values. */
2632
7ceba241
LP		 2633 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2634 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
915b3753 2635 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
7ceba241 2636 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
18fa6b27 2637
e9ddabc2 2638 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
18fa6b27 2639
915b3753
LP		 2640 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2641 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
18fa6b27 2642
e12919e8
LP		 2643 log_struct(LOG_INFO,
2644 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2645 "KERNEL_USEC="USEC_FMT, kernel_usec,
2646 "INITRD_USEC="USEC_FMT, initrd_usec,
2647 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2648 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2649 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2650 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2651 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2652 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2653 NULL);
18fa6b27 2654 } else {
915b3753 2655 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
18fa6b27
LP		 2656 initrd_usec = 0;
2657
81270860 2658 log_struct(LOG_INFO,
1ca6783f 2659 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
e12919e8 2660 "KERNEL_USEC="USEC_FMT, kernel_usec,
ccd06097 2661 "USERSPACE_USEC="USEC_FMT, userspace_usec,
e12919e8
LP		 2662 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2663 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2664 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2fa4092c 2665 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
81270860 2666 NULL);
e12919e8
LP		 2667 }
2668 } else {
2669 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2670 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2671
2672 log_struct(LOG_INFO,
2673 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2674 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2675 "MESSAGE=Startup finished in %s.",
2676 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2677 NULL);
18fa6b27 2678 }
b0c918b9 2679
db785129 2680 SET_FOREACH(u, m->startup_units, i)
285cd771
UTL		 2681 if (u->cgroup_path)
2682 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
95ae05c0 2683
718db961 2684 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
530345e7
LP		 2685
2686 sd_notifyf(false,
af4ec430
LP		 2687 "READY=1\n"
2688 "STATUS=Startup finished in %s.",
2fa4092c 2689 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
b0c918b9
LP		 2690}
2691
07719a21
LP		 2692static int create_generator_dir(Manager *m, char **generator, const char *name) {
2693 char *p;
2694 int r;
2695
2696 assert(m);
2697 assert(generator);
2698 assert(name);
2699
2700 if (*generator)
2701 return 0;
2702
67445f4e 2703 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
fcc81ea3 2704 /* systemd --system, not running --test */
07719a21
LP		 2705
2706 p = strappend("/run/systemd/", name);
0d0f0c50
SL		 2707 if (!p)
2708 return log_oom();
07719a21 2709
fcc81ea3
KS		 2710 r = mkdir_p_label(p, 0755);
2711 if (r < 0) {
2712 log_error("Failed to create generator directory %s: %s",
2713 p, strerror(-r));
2714 free(p);
2715 return r;
2716 }
2717 } else if (m->running_as == SYSTEMD_USER) {
2718 const char *s = NULL;
2719
2720 s = getenv("XDG_RUNTIME_DIR");
2721 if (!s)
2722 return -EINVAL;
2723 p = strjoin(s, "/systemd/", name, NULL);
2724 if (!p)
2725 return log_oom();
2726
d2e54fae 2727 r = mkdir_p_label(p, 0755);
07719a21 2728 if (r < 0) {
7ad94c71
ZJS		 2729 log_error("Failed to create generator directory %s: %s",
2730 p, strerror(-r));
07719a21
LP		 2731 free(p);
2732 return r;
2733 }
2734 } else {
fcc81ea3
KS		 2735 /* systemd --system --test */
2736
b7def684 2737 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
0d0f0c50
SL		 2738 if (!p)
2739 return log_oom();
07719a21
LP		 2740
2741 if (!mkdtemp(p)) {
7ad94c71
ZJS		 2742 log_error("Failed to create generator directory %s: %m",
2743 p);
34bf0281 2744 free(p);
07719a21
LP		 2745 return -errno;
2746 }
2747 }
2748
2749 *generator = p;
2750 return 0;
2751}
2752
2753static void trim_generator_dir(Manager *m, char **generator) {
2754 assert(m);
2755 assert(generator);
2756
2757 if (!*generator)
2758 return;
2759
2760 if (rmdir(*generator) >= 0) {
2761 free(*generator);
2762 *generator = NULL;
2763 }
2764
2765 return;
2766}
2767
5a1e9937 2768void manager_run_generators(Manager *m) {
718db961 2769 _cleanup_closedir_ DIR *d = NULL;
5a1e9937 2770 const char *generator_path;
07719a21 2771 const char *argv[5];
07719a21 2772 int r;
5a1e9937
LP		 2773
2774 assert(m);
2775
0d8c31ff
ZJS		 2776 if (m->test_run)
2777 return;
2778
67445f4e 2779 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
07719a21
LP		 2780 d = opendir(generator_path);
2781 if (!d) {
5a1e9937
LP		 2782 if (errno == ENOENT)
2783 return;
2784
7ad94c71
ZJS		 2785 log_error("Failed to enumerate generator directory %s: %m",
2786 generator_path);
5a1e9937
LP		 2787 return;
2788 }
2789
07719a21
LP		 2790 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2791 if (r < 0)
2792 goto finish;
f1d19aa4 2793
07719a21
LP		 2794 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2795 if (r < 0)
2796 goto finish;
5a1e9937 2797
07719a21
LP		 2798 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2799 if (r < 0)
2800 goto finish;
5a1e9937 2801
83cc030f
LP		 2802 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2803 argv[1] = m->generator_unit_path;
07719a21
LP		 2804 argv[2] = m->generator_unit_path_early;
2805 argv[3] = m->generator_unit_path_late;
2806 argv[4] = NULL;
5a1e9937 2807
718db961 2808 RUN_WITH_UMASK(0022)
e2680723 2809 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
5a1e9937 2810
718db961 2811finish:
07719a21
LP		 2812 trim_generator_dir(m, &m->generator_unit_path);
2813 trim_generator_dir(m, &m->generator_unit_path_early);
2814 trim_generator_dir(m, &m->generator_unit_path_late);
5a1e9937
LP		 2815}
2816
07719a21 2817static void remove_generator_dir(Manager *m, char **generator) {
5a1e9937 2818 assert(m);
07719a21 2819 assert(generator);
5a1e9937 2820
07719a21 2821 if (!*generator)
5a1e9937
LP		 2822 return;
2823
07719a21
LP		 2824 strv_remove(m->lookup_paths.unit_path, *generator);
2825 rm_rf(*generator, false, true, false);
5a1e9937 2826
07719a21
LP		 2827 free(*generator);
2828 *generator = NULL;
2829}
2830
2831void manager_undo_generators(Manager *m) {
2832 assert(m);
2833
2834 remove_generator_dir(m, &m->generator_unit_path);
2835 remove_generator_dir(m, &m->generator_unit_path_early);
2836 remove_generator_dir(m, &m->generator_unit_path_late);
5a1e9937
LP		 2837}
2838
718db961
LP		 2839int manager_environment_add(Manager *m, char **minus, char **plus) {
2840 char **a = NULL, **b = NULL, **l;
97d0e5f8 2841 assert(m);
bcd8e6d1 2842
718db961 2843 l = m->environment;
bcd8e6d1 2844
718db961
LP		 2845 if (!strv_isempty(minus)) {
2846 a = strv_env_delete(l, 1, minus);
2847 if (!a)
2848 return -ENOMEM;
2849
2850 l = a;
2851 }
2852
2853 if (!strv_isempty(plus)) {
2854 b = strv_env_merge(2, l, plus);
aa9f8a30
AH		 2855 if (!b) {
2856 strv_free(a);
718db961 2857 return -ENOMEM;
aa9f8a30 2858 }
bcd8e6d1 2859
718db961
LP		 2860 l = b;
2861 }
2862
2863 if (m->environment != l)
2864 strv_free(m->environment);
2865 if (a != l)
2866 strv_free(a);
2867 if (b != l)
2868 strv_free(b);
2869
f069efb4
LP		 2870 m->environment = l;
2871 manager_clean_environment(m);
2872 strv_sort(m->environment);
2873
97d0e5f8
UTL		 2874 return 0;
2875}
2876
c93ff2e9
FC		 2877int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2878 int i;
2879
2880 assert(m);
2881
517d56b1 2882 for (i = 0; i < _RLIMIT_MAX; i++) {
07719a21
LP		 2883 if (!default_rlimit[i])
2884 continue;
c93ff2e9 2885
07719a21
LP		 2886 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2887 if (!m->rlimit[i])
2888 return -ENOMEM;
c93ff2e9
FC		 2889 }
2890
2891 return 0;
2892}
2893
4cfa2c99 2894void manager_recheck_journal(Manager *m) {
f1dd0c3f
LP		 2895 Unit *u;
2896
2897 assert(m);
2898
67445f4e 2899 if (m->running_as != SYSTEMD_SYSTEM)
f1dd0c3f
LP		 2900 return;
2901
731a676c
LP		 2902 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2903 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
4cfa2c99 2904 log_close_journal();
731a676c 2905 return;
f1dd0c3f
LP		 2906 }
2907
731a676c
LP		 2908 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2909 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
4cfa2c99 2910 log_close_journal();
731a676c
LP		 2911 return;
2912 }
f1dd0c3f 2913
731a676c
LP		 2914 /* Hmm, OK, so the socket is fully up and the service is up
2915 * too, then let's make use of the thing. */
f1dd0c3f
LP		 2916 log_open();
2917}
2918
d450b6f2 2919void manager_set_show_status(Manager *m, ShowStatus mode) {
27d340c7 2920 assert(m);
d450b6f2 2921 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
27d340c7 2922
67445f4e 2923 if (m->running_as != SYSTEMD_SYSTEM)
27d340c7
LP		 2924 return;
2925
d450b6f2 2926 m->show_status = mode;
27d340c7 2927
d450b6f2 2928 if (mode > 0)
27d340c7
LP		 2929 touch("/run/systemd/show-status");
2930 else
2931 unlink("/run/systemd/show-status");
2932}
2933
6084e22e 2934static bool manager_get_show_status(Manager *m) {
27d340c7
LP		 2935 assert(m);
2936
67445f4e 2937 if (m->running_as != SYSTEMD_SYSTEM)
27d340c7
LP		 2938 return false;
2939
31a7eb86
ZJS		 2940 if (m->no_console_output)
2941 return false;
2942
d81afec1 2943 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
08510627
LP		 2944 return false;
2945
e46b13c8
ZJS		 2946 /* If we cannot find out the status properly, just proceed. */
2947 if (manager_check_ask_password(m) > 0)
2948 return false;
2949
d450b6f2 2950 if (m->show_status > 0)
27d340c7
LP		 2951 return true;
2952
2953 /* If Plymouth is running make sure we show the status, so
2954 * that there's something nice to see when people press Esc */
27d340c7
LP		 2955 return plymouth_running();
2956}
68b29a9f 2957
e2680723
LP		 2958void manager_set_first_boot(Manager *m, bool b) {
2959 assert(m);
2960
2961 if (m->running_as != SYSTEMD_SYSTEM)
2962 return;
2963
2964 m->first_boot = b;
2965
2966 if (m->first_boot)
2967 touch("/run/systemd/first-boot");
2968 else
2969 unlink("/run/systemd/first-boot");
2970}
2971
984a2be4 2972void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
25cee550
MS		 2973 va_list ap;
2974
2975 if (!manager_get_show_status(m))
2976 return;
2977
03b717a3
MS		 2978 /* XXX We should totally drop the check for ephemeral here
2979 * and thus effectively make 'Type=idle' pointless. */
2980 if (ephemeral && m->n_on_console > 0)
2981 return;
2982
25cee550 2983 va_start(ap, format);
984a2be4 2984 status_vprintf(status, true, ephemeral, format, ap);
25cee550
MS		 2985 va_end(ap);
2986}
2987
a57f7e2c
LP		 2988int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2989 _cleanup_free_ char *p = NULL;
2990 Unit *found;
2991
2992 assert(m);
2993 assert(path);
2994 assert(suffix);
2995 assert(_found);
2996
2997 p = unit_name_from_path(path, suffix);
2998 if (!p)
2999 return -ENOMEM;
3000
3001 found = manager_get_unit(m, p);
3002 if (!found) {
3003 *_found = NULL;
3004 return 0;
3005 }
3006
3007 *_found = found;
3008 return 1;
3009}
3010
3011Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3012 char p[strlen(path)+1];
3013
3014 assert(m);
3015 assert(path);
3016
3017 strcpy(p, path);
3018 path_kill_slashes(p);
3019
3020 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3021}
e66cf1a3
LP		 3022
3023const char *manager_get_runtime_prefix(Manager *m) {
f755e3b7 3024 assert(m);
e66cf1a3
LP		 3025
3026 return m->running_as == SYSTEMD_SYSTEM ?
3027 "/run" :
3028 getenv("XDG_RUNTIME_DIR");
3029}
f755e3b7
LP		 3030
3031ManagerState manager_state(Manager *m) {
3032 Unit *u;
3033
3034 assert(m);
3035
3036 /* Did we ever finish booting? If not then we are still starting up */
d81afec1
LP		 3037 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3038
3039 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3040 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3041 return MANAGER_INITIALIZING;
3042
f755e3b7 3043 return MANAGER_STARTING;
d81afec1 3044 }
f755e3b7
LP		 3045
3046 /* Is the special shutdown target queued? If so, we are in shutdown state */
3047 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3048 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3049 return MANAGER_STOPPING;
3050
3051 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3052 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3053 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3054 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3055 return MANAGER_MAINTENANCE;
3056
3057 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3058 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3059 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3060 return MANAGER_MAINTENANCE;
3061
3062 /* Are there any failed units? If so, we are in degraded mode */
3063 if (set_size(m->failed_units) > 0)
3064 return MANAGER_DEGRADED;
3065
3066 return MANAGER_RUNNING;
3067}
3068
3069static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
d81afec1 3070 [MANAGER_INITIALIZING] = "initializing",
f755e3b7
LP		 3071 [MANAGER_STARTING] = "starting",
3072 [MANAGER_RUNNING] = "running",
3073 [MANAGER_DEGRADED] = "degraded",
3074 [MANAGER_MAINTENANCE] = "maintenance",
3075 [MANAGER_STOPPING] = "stopping",
3076};
3077
3078DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
Unnamed repository; edit this file 'description' to name the repository.