]> 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
update TODO
[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
127d5fd1 197 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, 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
0c3f25e0 665 if (m->running_as == SYSTEMD_SYSTEM) {
7181dbdb 666 m->notify_socket = strdup("/run/systemd/notify");
0c3f25e0
CG		 667 if (!m->notify_socket)
668 return log_oom();
669 } else {
7181dbdb 670 const char *e;
d86f9d52 671
7181dbdb
LP		 672 e = getenv("XDG_RUNTIME_DIR");
673 if (!e) {
674 log_error("XDG_RUNTIME_DIR is not set: %m");
675 return -EINVAL;
676 }
677
678 m->notify_socket = strappend(e, "/systemd/notify");
0c3f25e0
CG		 679 if (!m->notify_socket)
680 return log_oom();
681
682 mkdir_parents_label(m->notify_socket, 0755);
7181dbdb 683 }
7181dbdb
LP		 684
685 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
686 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
d86f9d52 687 if (r < 0) {
70af4d17 688 log_error("bind(%s) failed: %m", sa.un.sun_path);
e7bc5196
ZJS		 689 if (errno == EADDRINUSE) {
690 log_notice("Removing %s socket and trying again.", m->notify_socket);
691 r = unlink(m->notify_socket);
692 if (r < 0) {
693 log_error("Failed to remove %s: %m", m->notify_socket);
694 return -EADDRINUSE;
695 }
696
697 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
698 if (r < 0) {
699 log_error("bind(%s) failed: %m", sa.un.sun_path);
700 return -errno;
701 }
702 } else
703 return -errno;
d86f9d52
LP		 704 }
705
706 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
707 if (r < 0) {
708 log_error("SO_PASSCRED failed: %m");
709 return -errno;
710 }
711
d86f9d52
LP		 712 m->notify_fd = fd;
713 fd = -1;
714
715 log_debug("Using notification socket %s", m->notify_socket);
716 }
717
718 if (!m->notify_event_source) {
151b9b96 719 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
d86f9d52
LP		 720 if (r < 0) {
721 log_error("Failed to allocate notify event source: %s", strerror(-r));
722 return -errno;
723 }
724
725 /* Process signals a bit earlier than SIGCHLD, so that we can
726 * still identify to which service an exit message belongs */
727 r = sd_event_source_set_priority(m->notify_event_source, -7);
728 if (r < 0) {
729 log_error("Failed to set priority of notify event source: %s", strerror(-r));
730 return r;
731 }
732 }
733
734 return 0;
735}
736
737static int manager_setup_kdbus(Manager *m) {
5bf348d7 738#ifdef ENABLE_KDBUS
d86f9d52
LP		 739 _cleanup_free_ char *p = NULL;
740
741 assert(m);
742
0d8c31ff 743 if (m->test_run || m->kdbus_fd >= 0)
d86f9d52
LP		 744 return 0;
745
f2769777 746 m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
d86f9d52
LP		 747 if (m->kdbus_fd < 0) {
748 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
749 return m->kdbus_fd;
750 }
751
752 log_debug("Successfully set up kdbus on %s", p);
753
754 /* Create the namespace directory here, so that the contents
755 * of that directory is not visible to non-root users. This is
756 * necessary to ensure that users cannot get access to busses
757 * of virtualized users when no UID namespacing is used. */
88c59cb3 758 if (m->running_as == SYSTEMD_SYSTEM)
486e99a3 759 mkdir_p_label("/dev/kdbus/domain", 0700);
d86f9d52
LP		 760#endif
761
762 return 0;
763}
764
765static int manager_connect_bus(Manager *m, bool reexecuting) {
766 bool try_bus_connect;
767
768 assert(m);
769
0d8c31ff
ZJS		 770 if (m->test_run)
771 return 0;
772
d86f9d52
LP		 773 try_bus_connect =
774 m->kdbus_fd >= 0 ||
775 reexecuting ||
776 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
777
778 /* Try to connect to the busses, if possible. */
779 return bus_init(m, try_bus_connect);
780}
781
23a177ef 782static unsigned manager_dispatch_cleanup_queue(Manager *m) {
595ed347 783 Unit *u;
23a177ef
LP		 784 unsigned n = 0;
785
786 assert(m);
787
595ed347
MS		 788 while ((u = m->cleanup_queue)) {
789 assert(u->in_cleanup_queue);
23a177ef 790
595ed347 791 unit_free(u);
23a177ef
LP		 792 n++;
793 }
794
795 return n;
796}
797
eced69b3 798enum {
35b8ca3a 799 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
eced69b3
LP		 800 GC_OFFSET_UNSURE, /* No clue */
801 GC_OFFSET_GOOD, /* We still need this unit */
802 GC_OFFSET_BAD, /* We don't need this unit anymore */
803 _GC_OFFSET_MAX
804};
805
806static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
701cc384
LP		 807 Iterator i;
808 Unit *other;
eced69b3 809 bool is_bad;
701cc384
LP		 810
811 assert(u);
812
ac155bb8
MS		 813 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
814 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
815 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
701cc384
LP		 816 return;
817
ac155bb8 818 if (u->in_cleanup_queue)
701cc384
LP		 819 goto bad;
820
821 if (unit_check_gc(u))
822 goto good;
823
ac155bb8 824 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
eced69b3
LP		 825
826 is_bad = true;
827
ac155bb8 828 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
701cc384
LP		 829 unit_gc_sweep(other, gc_marker);
830
ac155bb8 831 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
701cc384 832 goto good;
eced69b3 833
ac155bb8 834 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
eced69b3 835 is_bad = false;
701cc384
LP		 836 }
837
eced69b3
LP		 838 if (is_bad)
839 goto bad;
840
841 /* We were unable to find anything out about this entry, so
842 * let's investigate it later */
ac155bb8 843 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
eced69b3
LP		 844 unit_add_to_gc_queue(u);
845 return;
846
701cc384 847bad:
eced69b3
LP		 848 /* We definitely know that this one is not useful anymore, so
849 * let's mark it for deletion */
ac155bb8 850 u->gc_marker = gc_marker + GC_OFFSET_BAD;
eced69b3 851 unit_add_to_cleanup_queue(u);
701cc384
LP		 852 return;
853
854good:
ac155bb8 855 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
701cc384
LP		 856}
857
858static unsigned manager_dispatch_gc_queue(Manager *m) {
595ed347 859 Unit *u;
701cc384 860 unsigned n = 0;
eced69b3 861 unsigned gc_marker;
701cc384
LP		 862
863 assert(m);
864
cf1265e1 865 /* log_debug("Running GC..."); */
701cc384 866
eced69b3
LP		 867 m->gc_marker += _GC_OFFSET_MAX;
868 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
c9c0cadb 869 m->gc_marker = 1;
701cc384 870
eced69b3
LP		 871 gc_marker = m->gc_marker;
872
595ed347
MS		 873 while ((u = m->gc_queue)) {
874 assert(u->in_gc_queue);
701cc384 875
595ed347 876 unit_gc_sweep(u, gc_marker);
eced69b3 877
71fda00f 878 LIST_REMOVE(gc_queue, m->gc_queue, u);
595ed347 879 u->in_gc_queue = false;
701cc384
LP		 880
881 n++;
882
595ed347
MS		 883 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
884 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
66870f90 885 log_debug_unit(u->id, "Collecting %s", u->id);
595ed347
MS		 886 u->gc_marker = gc_marker + GC_OFFSET_BAD;
887 unit_add_to_cleanup_queue(u);
701cc384
LP		 888 }
889 }
890
891 m->n_in_gc_queue = 0;
701cc384
LP		 892
893 return n;
894}
895
a16e1123 896static void manager_clear_jobs_and_units(Manager *m) {
a16e1123 897 Unit *u;
60918275
LP		 898
899 assert(m);
900
87f0e418
LP		 901 while ((u = hashmap_first(m->units)))
902 unit_free(u);
964e0949
LP		 903
904 manager_dispatch_cleanup_queue(m);
905
906 assert(!m->load_queue);
907 assert(!m->run_queue);
908 assert(!m->dbus_unit_queue);
909 assert(!m->dbus_job_queue);
910 assert(!m->cleanup_queue);
911 assert(!m->gc_queue);
912
964e0949
LP		 913 assert(hashmap_isempty(m->jobs));
914 assert(hashmap_isempty(m->units));
9e9e2b72
MS		 915
916 m->n_on_console = 0;
917 m->n_running_jobs = 0;
a16e1123
LP		 918}
919
920void manager_free(Manager *m) {
921 UnitType c;
c93ff2e9 922 int i;
87f0e418 923
a16e1123
LP		 924 assert(m);
925
926 manager_clear_jobs_and_units(m);
23a177ef 927
7824bbeb
LP		 928 for (c = 0; c < _UNIT_TYPE_MAX; c++)
929 if (unit_vtable[c]->shutdown)
930 unit_vtable[c]->shutdown(m);
931
a16e1123
LP		 932 /* If we reexecute ourselves, we keep the root cgroup
933 * around */
c6c18be3 934 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
8e274523 935
5a1e9937
LP		 936 manager_undo_generators(m);
937
5e8d1c9a 938 bus_done(m);
ea430986 939
87f0e418 940 hashmap_free(m->units);
60918275 941 hashmap_free(m->jobs);
5ba6985b
LP		 942 hashmap_free(m->watch_pids1);
943 hashmap_free(m->watch_pids2);
05e343b7 944 hashmap_free(m->watch_bus);
9152c765 945
95ae05c0 946 set_free(m->startup_units);
f755e3b7
LP		 947 set_free(m->failed_units);
948
718db961
LP		 949 sd_event_source_unref(m->signal_event_source);
950 sd_event_source_unref(m->notify_event_source);
951 sd_event_source_unref(m->time_change_event_source);
952 sd_event_source_unref(m->jobs_in_progress_event_source);
953 sd_event_source_unref(m->idle_pipe_event_source);
752b5905 954 sd_event_source_unref(m->run_queue_event_source);
718db961 955
03e334a1
LP		 956 safe_close(m->signal_fd);
957 safe_close(m->notify_fd);
958 safe_close(m->time_change_fd);
959 safe_close(m->kdbus_fd);
718db961 960
e46b13c8
ZJS		 961 manager_close_ask_password(m);
962
718db961
LP		 963 manager_close_idle_pipe(m);
964
9670d583 965 udev_unref(m->udev);
718db961 966 sd_event_unref(m->event);
60918275 967
c952c6ec
LP		 968 free(m->notify_socket);
969
84e3543e 970 lookup_paths_free(&m->lookup_paths);
1137a57c 971 strv_free(m->environment);
036643a2 972
4ad49000 973 hashmap_free(m->cgroup_unit);
c6c18be3 974 set_free_free(m->unit_path_cache);
33be102a 975
664f88a7
LP		 976 free(m->switch_root);
977 free(m->switch_root_init);
978
517d56b1 979 for (i = 0; i < _RLIMIT_MAX; i++)
c93ff2e9
FC		 980 free(m->rlimit[i]);
981
a57f7e2c
LP		 982 assert(hashmap_isempty(m->units_requiring_mounts_for));
983 hashmap_free(m->units_requiring_mounts_for);
984
60918275
LP		 985 free(m);
986}
987
a16e1123
LP		 988int manager_enumerate(Manager *m) {
989 int r = 0, q;
f50e0a01 990 UnitType c;
f50e0a01
LP		 991
992 assert(m);
993
a16e1123
LP		 994 /* Let's ask every type to load all units from disk/kernel
995 * that it might know */
f50e0a01 996 for (c = 0; c < _UNIT_TYPE_MAX; c++)
a57f7e2c
LP		 997 if (unit_vtable[c]->enumerate) {
998 q = unit_vtable[c]->enumerate(m);
999 if (q < 0)
a16e1123 1000 r = q;
a57f7e2c 1001 }
f50e0a01
LP		 1002
1003 manager_dispatch_load_queue(m);
a16e1123
LP		 1004 return r;
1005}
1006
9588bc32 1007static int manager_coldplug(Manager *m) {
8f8f05a9 1008 int r = 0;
a16e1123
LP		 1009 Iterator i;
1010 Unit *u;
1011 char *k;
1012
1013 assert(m);
f50e0a01
LP		 1014
1015 /* Then, let's set up their initial state. */
1016 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
8f8f05a9 1017 int q;
f50e0a01
LP		 1018
1019 /* ignore aliases */
ac155bb8 1020 if (u->id != k)
f50e0a01
LP		 1021 continue;
1022
8f8f05a9
LP		 1023 q = unit_coldplug(u);
1024 if (q < 0)
cca098b0 1025 r = q;
f50e0a01
LP		 1026 }
1027
a16e1123
LP		 1028 return r;
1029}
1030
fe51822e
LP		 1031static void manager_build_unit_path_cache(Manager *m) {
1032 char **i;
807d0cca 1033 _cleanup_closedir_ DIR *d = NULL;
fe51822e
LP		 1034 int r;
1035
1036 assert(m);
1037
1038 set_free_free(m->unit_path_cache);
1039
d5099efc 1040 m->unit_path_cache = set_new(&string_hash_ops);
874310b7 1041 if (!m->unit_path_cache) {
fe51822e
LP		 1042 log_error("Failed to allocate unit path cache.");
1043 return;
1044 }
1045
1046 /* This simply builds a list of files we know exist, so that
1047 * we don't always have to go to disk */
1048
1049 STRV_FOREACH(i, m->lookup_paths.unit_path) {
1050 struct dirent *de;
1051
bd0af849
ZJS		 1052 d = opendir(*i);
1053 if (!d) {
874310b7
ZJS		 1054 if (errno != ENOENT)
1055 log_error("Failed to open directory %s: %m", *i);
fe51822e
LP		 1056 continue;
1057 }
1058
1059 while ((de = readdir(d))) {
1060 char *p;
1061
1062 if (ignore_file(de->d_name))
1063 continue;
1064
b7def684 1065 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
44d91056 1066 if (!p) {
fe51822e
LP		 1067 r = -ENOMEM;
1068 goto fail;
1069 }
1070
ef42202a
ZJS		 1071 r = set_consume(m->unit_path_cache, p);
1072 if (r < 0)
fe51822e 1073 goto fail;
fe51822e
LP		 1074 }
1075
1076 closedir(d);
1077 d = NULL;
1078 }
1079
1080 return;
1081
1082fail:
1083 log_error("Failed to build unit path cache: %s", strerror(-r));
1084
1085 set_free_free(m->unit_path_cache);
1086 m->unit_path_cache = NULL;
fe51822e
LP		 1087}
1088
9588bc32
LP		 1089
1090static int manager_distribute_fds(Manager *m, FDSet *fds) {
1091 Unit *u;
1092 Iterator i;
1093 int r;
1094
1095 assert(m);
1096
1097 HASHMAP_FOREACH(u, m->units, i) {
1098
1099 if (fdset_size(fds) <= 0)
1100 break;
1101
1102 if (UNIT_VTABLE(u)->distribute_fds) {
1103 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1104 if (r < 0)
1105 return r;
1106 }
1107 }
1108
1109 return 0;
1110}
1111
a16e1123
LP		 1112int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1113 int r, q;
1114
1115 assert(m);
1116
518d10e9 1117 dual_timestamp_get(&m->generators_start_timestamp);
5a1e9937 1118 manager_run_generators(m);
518d10e9 1119 dual_timestamp_get(&m->generators_finish_timestamp);
5a1e9937 1120
07719a21
LP		 1121 r = lookup_paths_init(
1122 &m->lookup_paths, m->running_as, true,
12ed81d9 1123 NULL,
07719a21
LP		 1124 m->generator_unit_path,
1125 m->generator_unit_path_early,
1126 m->generator_unit_path_late);
1127 if (r < 0)
1128 return r;
1129
fe51822e
LP		 1130 manager_build_unit_path_cache(m);
1131
9f611ad8
LP		 1132 /* If we will deserialize make sure that during enumeration
1133 * this is already known, so we increase the counter here
1134 * already */
1135 if (serialization)
a7556052 1136 m->n_reloading ++;
9f611ad8 1137
a16e1123 1138 /* First, enumerate what we can from all config files */
718db961 1139 dual_timestamp_get(&m->units_load_start_timestamp);
a16e1123 1140 r = manager_enumerate(m);
718db961 1141 dual_timestamp_get(&m->units_load_finish_timestamp);
a16e1123
LP		 1142
1143 /* Second, deserialize if there is something to deserialize */
1cd974ed
ZJS		 1144 if (serialization)
1145 r = manager_deserialize(m, serialization, fds);
a16e1123 1146
01e10de3
LP		 1147 /* Any fds left? Find some unit which wants them. This is
1148 * useful to allow container managers to pass some file
1149 * descriptors to us pre-initialized. This enables
1150 * socket-based activation of entire containers. */
1151 if (fdset_size(fds) > 0) {
1152 q = manager_distribute_fds(m, fds);
1cd974ed 1153 if (q < 0 && r == 0)
01e10de3
LP		 1154 r = q;
1155 }
1156
d86f9d52
LP		 1157 /* We might have deserialized the notify fd, but if we didn't
1158 * then let's create the bus now */
1cd974ed
ZJS		 1159 q = manager_setup_notify(m);
1160 if (q < 0 && r == 0)
1161 r = q;
d86f9d52 1162
e3dd987c
LP		 1163 /* We might have deserialized the kdbus control fd, but if we
1164 * didn't, then let's create the bus now. */
1165 manager_setup_kdbus(m);
1166 manager_connect_bus(m, !!serialization);
8f8f05a9 1167 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
e3dd987c 1168
a16e1123 1169 /* Third, fire things up! */
07719a21 1170 q = manager_coldplug(m);
1cd974ed 1171 if (q < 0 && r == 0)
a16e1123
LP		 1172 r = q;
1173
9f611ad8 1174 if (serialization) {
a7556052
LP		 1175 assert(m->n_reloading > 0);
1176 m->n_reloading --;
71445ae7
LP		 1177
1178 /* Let's wait for the UnitNew/JobNew messages being
1179 * sent, before we notify that the reload is
1180 * finished */
1181 m->send_reloading_done = true;
9f611ad8
LP		 1182 }
1183
a16e1123 1184 return r;
f50e0a01
LP		 1185}
1186
718db961 1187int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
e5b5ae50 1188 int r;
7527cb52 1189 Transaction *tr;
e5b5ae50
LP		 1190
1191 assert(m);
1192 assert(type < _JOB_TYPE_MAX);
87f0e418 1193 assert(unit);
e5b5ae50 1194 assert(mode < _JOB_MODE_MAX);
60918275 1195
7358dc02
ZJS		 1196 if (mode == JOB_ISOLATE && type != JOB_START)
1197 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
c497c7a9 1198
7358dc02
ZJS		 1199 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1200 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
2528a7a6 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;
0aa281df 2073 const char *msg;
c1165f82 2074 int audit_fd;
e537352b 2075
c1165f82
LP		 2076 audit_fd = get_audit_fd();
2077 if (audit_fd < 0)
e537352b
LP		 2078 return;
2079
bbd3a7ba
LP		 2080 /* Don't generate audit events if the service was already
2081 * started and we're just deserializing */
a7556052 2082 if (m->n_reloading > 0)
bbd3a7ba
LP		 2083 return;
2084
67445f4e 2085 if (m->running_as != SYSTEMD_SYSTEM)
f1dd0c3f
LP		 2086 return;
2087
ac155bb8 2088 if (u->type != UNIT_SERVICE)
f1dd0c3f
LP		 2089 return;
2090
bd0af849
ZJS		 2091 p = unit_name_to_prefix_and_instance(u->id);
2092 if (!p) {
0aa281df 2093 log_oom();
e537352b
LP		 2094 return;
2095 }
2096
0aa281df
LP		 2097 msg = strappenda("unit=", p);
2098
2099 if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2100 if (errno == EPERM)
391ade86 2101 /* We aren't allowed to send audit messages?
44785992 2102 * Then let's not retry again. */
c1165f82 2103 close_audit_fd();
0aa281df 2104 else
44785992 2105 log_warning("Failed to send audit message: %m");
391ade86 2106 }
4927fcae 2107#endif
e537352b 2108
e537352b
LP		 2109}
2110
e983b760 2111void manager_send_unit_plymouth(Manager *m, Unit *u) {
1d749d04 2112 union sockaddr_union sa = PLYMOUTH_SOCKET;
2ba11090 2113
e983b760 2114 int n = 0;
2ba11090
ZJS		 2115 _cleanup_free_ char *message = NULL;
2116 _cleanup_close_ int fd = -1;
e983b760
LP		 2117
2118 /* Don't generate plymouth events if the service was already
2119 * started and we're just deserializing */
a7556052 2120 if (m->n_reloading > 0)
e983b760
LP		 2121 return;
2122
67445f4e 2123 if (m->running_as != SYSTEMD_SYSTEM)
e983b760
LP		 2124 return;
2125
3772995a
LP		 2126 if (detect_container(NULL) > 0)
2127 return;
2128
ac155bb8
MS		 2129 if (u->type != UNIT_SERVICE &&
2130 u->type != UNIT_MOUNT &&
2131 u->type != UNIT_SWAP)
e983b760
LP		 2132 return;
2133
2134 /* We set SOCK_NONBLOCK here so that we rather drop the
2135 * message then wait for plymouth */
e62d8c39
ZJS		 2136 fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2137 if (fd < 0) {
e983b760
LP		 2138 log_error("socket() failed: %m");
2139 return;
2140 }
2141
96707269 2142 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
e983b760 2143
2ba11090 2144 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
e983b760 2145 log_error("connect() failed: %m");
2ba11090 2146 return;
e983b760
LP		 2147 }
2148
ac155bb8 2149 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
0d0f0c50 2150 log_oom();
2ba11090 2151 return;
e983b760
LP		 2152 }
2153
2154 errno = 0;
2ba11090
ZJS		 2155 if (write(fd, message, n + 1) != n + 1)
2156 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
e983b760 2157 log_error("Failed to write Plymouth message: %m");
e983b760
LP		 2158}
2159
05e343b7
LP		 2160void manager_dispatch_bus_name_owner_changed(
2161 Manager *m,
2162 const char *name,
2163 const char* old_owner,
2164 const char *new_owner) {
2165
2166 Unit *u;
2167
2168 assert(m);
2169 assert(name);
2170
718db961
LP		 2171 u = hashmap_get(m->watch_bus, name);
2172 if (!u)
05e343b7
LP		 2173 return;
2174
2175 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2176}
2177
d8d5ab98 2178int manager_open_serialization(Manager *m, FILE **_f) {
8e33886e 2179 const char *path;
df28bc08 2180 int fd = -1;
a16e1123
LP		 2181 FILE *f;
2182
2183 assert(_f);
2184
8e33886e
ZJS		 2185 path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2186 fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
d86f9d52 2187 if (fd < 0)
a16e1123 2188 return -errno;
a16e1123 2189
a16e1123 2190 log_debug("Serializing state to %s", path);
a16e1123 2191
01e10de3 2192 f = fdopen(fd, "w+");
d86f9d52 2193 if (!f) {
03e334a1 2194 safe_close(fd);
a16e1123 2195 return -errno;
d86f9d52 2196 }
a16e1123
LP		 2197
2198 *_f = f;
2199
2200 return 0;
2201}
2202
b3680f49 2203int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
a16e1123
LP		 2204 Iterator i;
2205 Unit *u;
2206 const char *t;
4a9fd066 2207 char **e;
a16e1123
LP		 2208 int r;
2209
2210 assert(m);
2211 assert(f);
2212 assert(fds);
2213
a7556052 2214 m->n_reloading ++;
38c52d46 2215
01d67b43
LP		 2216 fprintf(f, "current-job-id=%i\n", m->current_job_id);
2217 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
33c5fae9
LP		 2218 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2219 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
01d67b43 2220
915b3753 2221 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
915b3753 2222 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
718db961 2223 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
e9ddabc2 2224 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
f38ed060 2225
26a1efdf 2226 if (!in_initrd()) {
915b3753 2227 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
f38ed060 2228 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
718db961
LP		 2229 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2230 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2231 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2232 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2233 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2234 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
f38ed060 2235 }
47a483a1 2236
b3680f49
HH		 2237 if (!switching_root) {
2238 STRV_FOREACH(e, m->environment) {
2239 _cleanup_free_ char *ce;
4a9fd066 2240
b3680f49 2241 ce = cescape(*e);
e3dd987c
LP		 2242 if (!ce)
2243 return -ENOMEM;
2244
2245 fprintf(f, "env=%s\n", *e);
b3680f49 2246 }
4a9fd066
OS		 2247 }
2248
d86f9d52
LP		 2249 if (m->notify_fd >= 0) {
2250 int copy;
2251
2252 copy = fdset_put_dup(fds, m->notify_fd);
2253 if (copy < 0)
2254 return copy;
2255
2256 fprintf(f, "notify-fd=%i\n", copy);
2257 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2258 }
2259
e3dd987c
LP		 2260 if (m->kdbus_fd >= 0) {
2261 int copy;
2262
2263 copy = fdset_put_dup(fds, m->kdbus_fd);
2264 if (copy < 0)
2265 return copy;
2266
2267 fprintf(f, "kdbus-fd=%i\n", copy);
2268 }
2269
8f8f05a9 2270 bus_track_serialize(m->subscribed, f);
6fa48533 2271
f2382a94
LP		 2272 fputc('\n', f);
2273
a16e1123 2274 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
ac155bb8 2275 if (u->id != t)
a16e1123
LP		 2276 continue;
2277
a16e1123 2278 /* Start marker */
ac155bb8 2279 fputs(u->id, f);
a16e1123
LP		 2280 fputc('\n', f);
2281
6fa48533
LP		 2282 r = unit_serialize(u, f, fds, !switching_root);
2283 if (r < 0) {
a7556052 2284 m->n_reloading --;
a16e1123 2285 return r;
38c52d46 2286 }
a16e1123
LP		 2287 }
2288
a7556052
LP		 2289 assert(m->n_reloading > 0);
2290 m->n_reloading --;
38c52d46 2291
a16e1123
LP		 2292 if (ferror(f))
2293 return -EIO;
2294
b23de6af
LP		 2295 r = bus_fdset_add_all(m, fds);
2296 if (r < 0)
2297 return r;
2298
a16e1123
LP		 2299 return 0;
2300}
2301
2302int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2303 int r = 0;
2304
2305 assert(m);
2306 assert(f);
2307
2308 log_debug("Deserializing state...");
2309
a7556052 2310 m->n_reloading ++;
82c64bf5 2311
10f8e83c 2312 for (;;) {
20c03b7b 2313 char line[LINE_MAX], *l;
10f8e83c
LP		 2314
2315 if (!fgets(line, sizeof(line), f)) {
2316 if (feof(f))
2317 r = 0;
2318 else
2319 r = -errno;
2320
2321 goto finish;
2322 }
2323
2324 char_array_0(line);
2325 l = strstrip(line);
2326
2327 if (l[0] == 0)
2328 break;
2329
01d67b43
LP		 2330 if (startswith(l, "current-job-id=")) {
2331 uint32_t id;
2332
2333 if (safe_atou32(l+15, &id) < 0)
46849c3f 2334 log_warning("Failed to parse current job id value %s", l+15);
01d67b43
LP		 2335 else
2336 m->current_job_id = MAX(m->current_job_id, id);
718db961 2337
33c5fae9
LP		 2338 } else if (startswith(l, "n-installed-jobs=")) {
2339 uint32_t n;
2340
2341 if (safe_atou32(l+17, &n) < 0)
46849c3f 2342 log_warning("Failed to parse installed jobs counter %s", l+17);
33c5fae9
LP		 2343 else
2344 m->n_installed_jobs += n;
718db961 2345
33c5fae9
LP		 2346 } else if (startswith(l, "n-failed-jobs=")) {
2347 uint32_t n;
2348
2349 if (safe_atou32(l+14, &n) < 0)
46849c3f 2350 log_warning("Failed to parse failed jobs counter %s", l+14);
33c5fae9
LP		 2351 else
2352 m->n_failed_jobs += n;
718db961 2353
01d67b43
LP		 2354 } else if (startswith(l, "taint-usr=")) {
2355 int b;
2356
e3dd987c
LP		 2357 b = parse_boolean(l+10);
2358 if (b < 0)
46849c3f 2359 log_warning("Failed to parse taint /usr flag %s", l+10);
01d67b43
LP		 2360 else
2361 m->taint_usr = m->taint_usr || b;
718db961 2362
915b3753
LP		 2363 } else if (startswith(l, "firmware-timestamp="))
2364 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2365 else if (startswith(l, "loader-timestamp="))
2366 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2367 else if (startswith(l, "kernel-timestamp="))
2368 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2369 else if (startswith(l, "initrd-timestamp="))
e9ddabc2 2370 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
915b3753
LP		 2371 else if (startswith(l, "userspace-timestamp="))
2372 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
10717a1a 2373 else if (startswith(l, "finish-timestamp="))
799fd0fd 2374 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
718db961
LP		 2375 else if (startswith(l, "security-start-timestamp="))
2376 dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2377 else if (startswith(l, "security-finish-timestamp="))
2378 dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2379 else if (startswith(l, "generators-start-timestamp="))
2380 dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2381 else if (startswith(l, "generators-finish-timestamp="))
2382 dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2383 else if (startswith(l, "units-load-start-timestamp="))
2384 dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2385 else if (startswith(l, "units-load-finish-timestamp="))
2386 dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
4a9fd066
OS		 2387 else if (startswith(l, "env=")) {
2388 _cleanup_free_ char *uce = NULL;
2389 char **e;
2390
2391 uce = cunescape(l+4);
2392 if (!uce) {
2393 r = -ENOMEM;
2394 goto finish;
2395 }
2396
2397 e = strv_env_set(m->environment, uce);
2398 if (!e) {
2399 r = -ENOMEM;
2400 goto finish;
2401 }
2402
2403 strv_free(m->environment);
2404 m->environment = e;
e3dd987c 2405
d86f9d52
LP		 2406 } else if (startswith(l, "notify-fd=")) {
2407 int fd;
2408
2409 if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
46849c3f 2410 log_warning("Failed to parse notify fd: %s", l + 10);
d86f9d52 2411 else {
03e334a1
LP		 2412 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2413 safe_close(m->notify_fd);
d86f9d52
LP		 2414 m->notify_fd = fdset_remove(fds, fd);
2415 }
2416
2417 } else if (startswith(l, "notify-socket=")) {
2418 char *n;
2419
2420 n = strdup(l+14);
2421 if (!n) {
2422 r = -ENOMEM;
2423 goto finish;
2424 }
2425
2426 free(m->notify_socket);
2427 m->notify_socket = n;
2428
e3dd987c
LP		 2429 } else if (startswith(l, "kdbus-fd=")) {
2430 int fd;
2431
8bf9fcf4 2432 if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
46849c3f 2433 log_warning("Failed to parse kdbus fd: %s", l + 9);
e3dd987c 2434 else {
03e334a1 2435 safe_close(m->kdbus_fd);
e3dd987c
LP		 2436 m->kdbus_fd = fdset_remove(fds, fd);
2437 }
2438
8f8f05a9 2439 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
46849c3f 2440 log_warning("Unknown serialization item '%s'", l);
10f8e83c
LP		 2441 }
2442
a16e1123
LP		 2443 for (;;) {
2444 Unit *u;
2445 char name[UNIT_NAME_MAX+2];
2446
2447 /* Start marker */
2448 if (!fgets(name, sizeof(name), f)) {
2449 if (feof(f))
10f8e83c
LP		 2450 r = 0;
2451 else
2452 r = -errno;
a16e1123 2453
82c64bf5 2454 goto finish;
a16e1123
LP		 2455 }
2456
2457 char_array_0(name);
2458
bd0af849
ZJS		 2459 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2460 if (r < 0)
82c64bf5 2461 goto finish;
a16e1123 2462
01e10de3
LP		 2463 r = unit_deserialize(u, f, fds);
2464 if (r < 0)
82c64bf5 2465 goto finish;
a16e1123
LP		 2466 }
2467
10f8e83c 2468finish:
145b1f79 2469 if (ferror(f))
82c64bf5 2470 r = -EIO;
a16e1123 2471
a7556052
LP		 2472 assert(m->n_reloading > 0);
2473 m->n_reloading --;
82c64bf5
LP		 2474
2475 return r;
a16e1123
LP		 2476}
2477
2478int manager_reload(Manager *m) {
2479 int r, q;
51d122af
ZJS		 2480 _cleanup_fclose_ FILE *f = NULL;
2481 _cleanup_fdset_free_ FDSet *fds = NULL;
a16e1123
LP		 2482
2483 assert(m);
2484
07719a21
LP		 2485 r = manager_open_serialization(m, &f);
2486 if (r < 0)
a16e1123
LP		 2487 return r;
2488
a7556052 2489 m->n_reloading ++;
718db961 2490 bus_manager_send_reloading(m, true);
38c52d46 2491
07719a21
LP		 2492 fds = fdset_new();
2493 if (!fds) {
a7556052 2494 m->n_reloading --;
51d122af 2495 return -ENOMEM;
a16e1123
LP		 2496 }
2497
b3680f49 2498 r = manager_serialize(m, f, fds, false);
07719a21 2499 if (r < 0) {
a7556052 2500 m->n_reloading --;
51d122af 2501 return r;
38c52d46 2502 }
a16e1123
LP		 2503
2504 if (fseeko(f, 0, SEEK_SET) < 0) {
a7556052 2505 m->n_reloading --;
51d122af 2506 return -errno;
a16e1123
LP		 2507 }
2508
2509 /* From here on there is no way back. */
2510 manager_clear_jobs_and_units(m);
5a1e9937 2511 manager_undo_generators(m);
84e3543e 2512 lookup_paths_free(&m->lookup_paths);
2ded0c04 2513
07719a21 2514 /* Find new unit paths */
5a1e9937
LP		 2515 manager_run_generators(m);
2516
07719a21
LP		 2517 q = lookup_paths_init(
2518 &m->lookup_paths, m->running_as, true,
12ed81d9 2519 NULL,
07719a21
LP		 2520 m->generator_unit_path,
2521 m->generator_unit_path_early,
2522 m->generator_unit_path_late);
2523 if (q < 0)
2524 r = q;
2525
5a1e9937
LP		 2526 manager_build_unit_path_cache(m);
2527
a16e1123 2528 /* First, enumerate what we can from all config files */
07719a21
LP		 2529 q = manager_enumerate(m);
2530 if (q < 0)
a16e1123
LP		 2531 r = q;
2532
2533 /* Second, deserialize our stored data */
07719a21
LP		 2534 q = manager_deserialize(m, f, fds);
2535 if (q < 0)
a16e1123
LP		 2536 r = q;
2537
2538 fclose(f);
2539 f = NULL;
2540
a2cc4a6c
ZJS		 2541 /* Re-register notify_fd as event source */
2542 q = manager_setup_notify(m);
2543 if (q < 0)
2544 r = q;
2545
a16e1123 2546 /* Third, fire things up! */
07719a21
LP		 2547 q = manager_coldplug(m);
2548 if (q < 0)
a16e1123
LP		 2549 r = q;
2550
a7556052
LP		 2551 assert(m->n_reloading > 0);
2552 m->n_reloading--;
9f611ad8 2553
71445ae7
LP		 2554 m->send_reloading_done = true;
2555
a16e1123
LP		 2556 return r;
2557}
2558
c17ec25e
MS		 2559bool manager_is_reloading_or_reexecuting(Manager *m) {
2560 assert(m);
2561
2562 return m->n_reloading != 0;
2563}
2564
fdf20a31 2565void manager_reset_failed(Manager *m) {
5632e374
LP		 2566 Unit *u;
2567 Iterator i;
2568
2569 assert(m);
2570
2571 HASHMAP_FOREACH(u, m->units, i)
fdf20a31 2572 unit_reset_failed(u);
5632e374
LP		 2573}
2574
31afa0a4 2575bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
8f6df3fa
LP		 2576 Unit *u;
2577
2578 assert(m);
2579 assert(name);
2580
2581 /* Returns true if the unit is inactive or going down */
bd0af849
ZJS		 2582 u = manager_get_unit(m, name);
2583 if (!u)
8f6df3fa
LP		 2584 return true;
2585
31afa0a4 2586 return unit_inactive_or_pending(u);
8f6df3fa
LP		 2587}
2588
56dacdbc 2589static void manager_notify_finished(Manager *m) {
7ceba241 2590 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
915b3753 2591 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
b0c918b9 2592
56dacdbc 2593 if (m->test_run)
b0c918b9
LP		 2594 return;
2595
67445f4e 2596 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
e03ae661 2597
915b3753
LP		 2598 /* Note that m->kernel_usec.monotonic is always at 0,
2599 * and m->firmware_usec.monotonic and
2600 * m->loader_usec.monotonic should be considered
2601 * negative values. */
2602
7ceba241
LP		 2603 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2604 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
915b3753 2605 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
7ceba241 2606 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
18fa6b27 2607
e9ddabc2 2608 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
18fa6b27 2609
915b3753
LP		 2610 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2611 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
18fa6b27 2612
e12919e8
LP		 2613 log_struct(LOG_INFO,
2614 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2615 "KERNEL_USEC="USEC_FMT, kernel_usec,
2616 "INITRD_USEC="USEC_FMT, initrd_usec,
2617 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2618 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2619 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2620 format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2621 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2622 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2623 NULL);
18fa6b27 2624 } else {
915b3753 2625 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
18fa6b27
LP		 2626 initrd_usec = 0;
2627
81270860 2628 log_struct(LOG_INFO,
1ca6783f 2629 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
e12919e8 2630 "KERNEL_USEC="USEC_FMT, kernel_usec,
ccd06097 2631 "USERSPACE_USEC="USEC_FMT, userspace_usec,
e12919e8
LP		 2632 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2633 format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2634 format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2fa4092c 2635 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
81270860 2636 NULL);
e12919e8
LP		 2637 }
2638 } else {
2639 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2640 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2641
2642 log_struct(LOG_INFO,
2643 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2644 "USERSPACE_USEC="USEC_FMT, userspace_usec,
2645 "MESSAGE=Startup finished in %s.",
2646 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2647 NULL);
18fa6b27 2648 }
b0c918b9 2649
718db961 2650 bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
530345e7
LP		 2651
2652 sd_notifyf(false,
af4ec430
LP		 2653 "READY=1\n"
2654 "STATUS=Startup finished in %s.",
2fa4092c 2655 format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
b0c918b9
LP		 2656}
2657
56dacdbc
ZJS		 2658void manager_check_finished(Manager *m) {
2659 Unit *u = NULL;
2660 Iterator i;
2661
2662 assert(m);
2663
2664 if (m->n_running_jobs == 0)
2665 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2666
2667 if (hashmap_size(m->jobs) > 0) {
2668
2669 if (m->jobs_in_progress_event_source)
2670 sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2671
2672 return;
2673 }
2674
2675 manager_flip_auto_status(m, false);
2676
2677 /* Notify Type=idle units that we are done now */
2678 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2679 manager_close_idle_pipe(m);
2680
2681 /* Turn off confirm spawn now */
2682 m->confirm_spawn = false;
2683
2684 /* No need to update ask password status when we're going non-interactive */
2685 manager_close_ask_password(m);
2686
2687 /* This is no longer the first boot */
2688 manager_set_first_boot(m, false);
2689
2690 if (dual_timestamp_is_set(&m->finish_timestamp))
2691 return;
2692
2693 dual_timestamp_get(&m->finish_timestamp);
2694
2695 manager_notify_finished(m);
2696
2697 SET_FOREACH(u, m->startup_units, i)
2698 if (u->cgroup_path)
2699 cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2700}
2701
07719a21
LP		 2702static int create_generator_dir(Manager *m, char **generator, const char *name) {
2703 char *p;
2704 int r;
2705
2706 assert(m);
2707 assert(generator);
2708 assert(name);
2709
2710 if (*generator)
2711 return 0;
2712
67445f4e 2713 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
fcc81ea3 2714 /* systemd --system, not running --test */
07719a21
LP		 2715
2716 p = strappend("/run/systemd/", name);
0d0f0c50
SL		 2717 if (!p)
2718 return log_oom();
07719a21 2719
fcc81ea3
KS		 2720 r = mkdir_p_label(p, 0755);
2721 if (r < 0) {
2722 log_error("Failed to create generator directory %s: %s",
2723 p, strerror(-r));
2724 free(p);
2725 return r;
2726 }
2727 } else if (m->running_as == SYSTEMD_USER) {
2728 const char *s = NULL;
2729
2730 s = getenv("XDG_RUNTIME_DIR");
2731 if (!s)
2732 return -EINVAL;
2733 p = strjoin(s, "/systemd/", name, NULL);
2734 if (!p)
2735 return log_oom();
2736
d2e54fae 2737 r = mkdir_p_label(p, 0755);
07719a21 2738 if (r < 0) {
7ad94c71
ZJS		 2739 log_error("Failed to create generator directory %s: %s",
2740 p, strerror(-r));
07719a21
LP		 2741 free(p);
2742 return r;
2743 }
2744 } else {
fcc81ea3
KS		 2745 /* systemd --system --test */
2746
b7def684 2747 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
0d0f0c50
SL		 2748 if (!p)
2749 return log_oom();
07719a21
LP		 2750
2751 if (!mkdtemp(p)) {
7ad94c71
ZJS		 2752 log_error("Failed to create generator directory %s: %m",
2753 p);
34bf0281 2754 free(p);
07719a21
LP		 2755 return -errno;
2756 }
2757 }
2758
2759 *generator = p;
2760 return 0;
2761}
2762
2763static void trim_generator_dir(Manager *m, char **generator) {
2764 assert(m);
2765 assert(generator);
2766
2767 if (!*generator)
2768 return;
2769
2770 if (rmdir(*generator) >= 0) {
2771 free(*generator);
2772 *generator = NULL;
2773 }
2774
2775 return;
2776}
2777
5a1e9937 2778void manager_run_generators(Manager *m) {
718db961 2779 _cleanup_closedir_ DIR *d = NULL;
5a1e9937 2780 const char *generator_path;
07719a21 2781 const char *argv[5];
07719a21 2782 int r;
5a1e9937
LP		 2783
2784 assert(m);
2785
0d8c31ff
ZJS		 2786 if (m->test_run)
2787 return;
2788
67445f4e 2789 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
07719a21
LP		 2790 d = opendir(generator_path);
2791 if (!d) {
5a1e9937
LP		 2792 if (errno == ENOENT)
2793 return;
2794
7ad94c71
ZJS		 2795 log_error("Failed to enumerate generator directory %s: %m",
2796 generator_path);
5a1e9937
LP		 2797 return;
2798 }
2799
07719a21
LP		 2800 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2801 if (r < 0)
2802 goto finish;
f1d19aa4 2803
07719a21
LP		 2804 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2805 if (r < 0)
2806 goto finish;
5a1e9937 2807
07719a21
LP		 2808 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2809 if (r < 0)
2810 goto finish;
5a1e9937 2811
83cc030f
LP		 2812 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2813 argv[1] = m->generator_unit_path;
07719a21
LP		 2814 argv[2] = m->generator_unit_path_early;
2815 argv[3] = m->generator_unit_path_late;
2816 argv[4] = NULL;
5a1e9937 2817
718db961 2818 RUN_WITH_UMASK(0022)
e2680723 2819 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
5a1e9937 2820
718db961 2821finish:
07719a21
LP		 2822 trim_generator_dir(m, &m->generator_unit_path);
2823 trim_generator_dir(m, &m->generator_unit_path_early);
2824 trim_generator_dir(m, &m->generator_unit_path_late);
5a1e9937
LP		 2825}
2826
07719a21 2827static void remove_generator_dir(Manager *m, char **generator) {
5a1e9937 2828 assert(m);
07719a21 2829 assert(generator);
5a1e9937 2830
07719a21 2831 if (!*generator)
5a1e9937
LP		 2832 return;
2833
07719a21
LP		 2834 strv_remove(m->lookup_paths.unit_path, *generator);
2835 rm_rf(*generator, false, true, false);
5a1e9937 2836
07719a21
LP		 2837 free(*generator);
2838 *generator = NULL;
2839}
2840
2841void manager_undo_generators(Manager *m) {
2842 assert(m);
2843
2844 remove_generator_dir(m, &m->generator_unit_path);
2845 remove_generator_dir(m, &m->generator_unit_path_early);
2846 remove_generator_dir(m, &m->generator_unit_path_late);
5a1e9937
LP		 2847}
2848
718db961
LP		 2849int manager_environment_add(Manager *m, char **minus, char **plus) {
2850 char **a = NULL, **b = NULL, **l;
97d0e5f8 2851 assert(m);
bcd8e6d1 2852
718db961 2853 l = m->environment;
bcd8e6d1 2854
718db961
LP		 2855 if (!strv_isempty(minus)) {
2856 a = strv_env_delete(l, 1, minus);
2857 if (!a)
2858 return -ENOMEM;
2859
2860 l = a;
2861 }
2862
2863 if (!strv_isempty(plus)) {
2864 b = strv_env_merge(2, l, plus);
aa9f8a30
AH		 2865 if (!b) {
2866 strv_free(a);
718db961 2867 return -ENOMEM;
aa9f8a30 2868 }
bcd8e6d1 2869
718db961
LP		 2870 l = b;
2871 }
2872
2873 if (m->environment != l)
2874 strv_free(m->environment);
2875 if (a != l)
2876 strv_free(a);
2877 if (b != l)
2878 strv_free(b);
2879
f069efb4
LP		 2880 m->environment = l;
2881 manager_clean_environment(m);
2882 strv_sort(m->environment);
2883
97d0e5f8
UTL		 2884 return 0;
2885}
2886
c93ff2e9
FC		 2887int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2888 int i;
2889
2890 assert(m);
2891
517d56b1 2892 for (i = 0; i < _RLIMIT_MAX; i++) {
07719a21
LP		 2893 if (!default_rlimit[i])
2894 continue;
c93ff2e9 2895
07719a21
LP		 2896 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2897 if (!m->rlimit[i])
2898 return -ENOMEM;
c93ff2e9
FC		 2899 }
2900
2901 return 0;
2902}
2903
4cfa2c99 2904void manager_recheck_journal(Manager *m) {
f1dd0c3f
LP		 2905 Unit *u;
2906
2907 assert(m);
2908
67445f4e 2909 if (m->running_as != SYSTEMD_SYSTEM)
f1dd0c3f
LP		 2910 return;
2911
731a676c
LP		 2912 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2913 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
4cfa2c99 2914 log_close_journal();
731a676c 2915 return;
f1dd0c3f
LP		 2916 }
2917
731a676c
LP		 2918 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2919 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
4cfa2c99 2920 log_close_journal();
731a676c
LP		 2921 return;
2922 }
f1dd0c3f 2923
731a676c
LP		 2924 /* Hmm, OK, so the socket is fully up and the service is up
2925 * too, then let's make use of the thing. */
f1dd0c3f
LP		 2926 log_open();
2927}
2928
d450b6f2 2929void manager_set_show_status(Manager *m, ShowStatus mode) {
27d340c7 2930 assert(m);
d450b6f2 2931 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
27d340c7 2932
67445f4e 2933 if (m->running_as != SYSTEMD_SYSTEM)
27d340c7
LP		 2934 return;
2935
d450b6f2 2936 m->show_status = mode;
27d340c7 2937
d450b6f2 2938 if (mode > 0)
27d340c7
LP		 2939 touch("/run/systemd/show-status");
2940 else
2941 unlink("/run/systemd/show-status");
2942}
2943
127d5fd1 2944static bool manager_get_show_status(Manager *m, StatusType type) {
27d340c7
LP		 2945 assert(m);
2946
67445f4e 2947 if (m->running_as != SYSTEMD_SYSTEM)
27d340c7
LP		 2948 return false;
2949
31a7eb86
ZJS		 2950 if (m->no_console_output)
2951 return false;
2952
d81afec1 2953 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
08510627
LP		 2954 return false;
2955
e46b13c8 2956 /* If we cannot find out the status properly, just proceed. */
ebc5788e 2957 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
e46b13c8
ZJS		 2958 return false;
2959
d450b6f2 2960 if (m->show_status > 0)
27d340c7
LP		 2961 return true;
2962
2963 /* If Plymouth is running make sure we show the status, so
2964 * that there's something nice to see when people press Esc */
27d340c7
LP		 2965 return plymouth_running();
2966}
68b29a9f 2967
e2680723
LP		 2968void manager_set_first_boot(Manager *m, bool b) {
2969 assert(m);
2970
2971 if (m->running_as != SYSTEMD_SYSTEM)
2972 return;
2973
2974 m->first_boot = b;
2975
2976 if (m->first_boot)
2977 touch("/run/systemd/first-boot");
2978 else
2979 unlink("/run/systemd/first-boot");
2980}
2981
127d5fd1 2982void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
25cee550
MS		 2983 va_list ap;
2984
127d5fd1 2985 if (!manager_get_show_status(m, type))
25cee550
MS		 2986 return;
2987
03b717a3
MS		 2988 /* XXX We should totally drop the check for ephemeral here
2989 * and thus effectively make 'Type=idle' pointless. */
127d5fd1 2990 if (type == STATUS_TYPE_EPHEMERAL && m->n_on_console > 0)
03b717a3
MS		 2991 return;
2992
25cee550 2993 va_start(ap, format);
127d5fd1 2994 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
25cee550
MS		 2995 va_end(ap);
2996}
2997
a57f7e2c
LP		 2998int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2999 _cleanup_free_ char *p = NULL;
3000 Unit *found;
3001
3002 assert(m);
3003 assert(path);
3004 assert(suffix);
3005 assert(_found);
3006
3007 p = unit_name_from_path(path, suffix);
3008 if (!p)
3009 return -ENOMEM;
3010
3011 found = manager_get_unit(m, p);
3012 if (!found) {
3013 *_found = NULL;
3014 return 0;
3015 }
3016
3017 *_found = found;
3018 return 1;
3019}
3020
3021Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3022 char p[strlen(path)+1];
3023
3024 assert(m);
3025 assert(path);
3026
3027 strcpy(p, path);
3028 path_kill_slashes(p);
3029
3030 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3031}
e66cf1a3
LP		 3032
3033const char *manager_get_runtime_prefix(Manager *m) {
f755e3b7 3034 assert(m);
e66cf1a3
LP		 3035
3036 return m->running_as == SYSTEMD_SYSTEM ?
3037 "/run" :
3038 getenv("XDG_RUNTIME_DIR");
3039}
f755e3b7
LP		 3040
3041ManagerState manager_state(Manager *m) {
3042 Unit *u;
3043
3044 assert(m);
3045
3046 /* Did we ever finish booting? If not then we are still starting up */
d81afec1
LP		 3047 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3048
3049 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3050 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3051 return MANAGER_INITIALIZING;
3052
f755e3b7 3053 return MANAGER_STARTING;
d81afec1 3054 }
f755e3b7
LP		 3055
3056 /* Is the special shutdown target queued? If so, we are in shutdown state */
3057 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3058 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3059 return MANAGER_STOPPING;
3060
3061 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3062 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3063 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3064 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3065 return MANAGER_MAINTENANCE;
3066
3067 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3068 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3069 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3070 return MANAGER_MAINTENANCE;
3071
3072 /* Are there any failed units? If so, we are in degraded mode */
3073 if (set_size(m->failed_units) > 0)
3074 return MANAGER_DEGRADED;
3075
3076 return MANAGER_RUNNING;
3077}
3078
3079static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
d81afec1 3080 [MANAGER_INITIALIZING] = "initializing",
f755e3b7
LP		 3081 [MANAGER_STARTING] = "starting",
3082 [MANAGER_RUNNING] = "running",
3083 [MANAGER_DEGRADED] = "degraded",
3084 [MANAGER_MAINTENANCE] = "maintenance",
3085 [MANAGER_STOPPING] = "stopping",
3086};
3087
3088DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
Unnamed repository; edit this file 'description' to name the repository.