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