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