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