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