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