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