]> 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
shared: FORMAT_TIMESTAMP_MAX -- include space for unicode weekdays
[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
LP		 25#include <sys/epoll.h>
26#include <signal.h>
27#include <sys/signalfd.h>
28#include <sys/wait.h>
29#include <unistd.h>
30#include <sys/poll.h>
e1414003
LP		 31#include <sys/reboot.h>
32#include <sys/ioctl.h>
33#include <linux/kd.h>
80876c20
LP		 34#include <termios.h>
35#include <fcntl.h>
a16e1123
LP		 36#include <sys/types.h>
37#include <sys/stat.h>
fe51822e 38#include <dirent.h>
830f6caa
LP		 39
40#ifdef HAVE_AUDIT
4927fcae 41#include <libaudit.h>
830f6caa 42#endif
60918275 43
877d54e9
LP		 44#include "systemd/sd-daemon.h"
45#include "systemd/sd-id128.h"
46#include "systemd/sd-messages.h"
81527be1 47
60918275 48#include "manager.h"
75778e21 49#include "transaction.h"
60918275
LP		 50#include "hashmap.h"
51#include "macro.h"
52#include "strv.h"
16354eff 53#include "log.h"
2a987ee8 54#include "util.h"
49e942b2 55#include "mkdir.h"
ea430986 56#include "ratelimit.h"
8e274523
LP		 57#include "cgroup.h"
58#include "mount-setup.h"
9e2f7c11 59#include "unit-name.h"
4139c1b2
LP		 60#include "dbus-unit.h"
61#include "dbus-job.h"
1137a57c 62#include "missing.h"
84e3543e 63#include "path-lookup.h"
514f4ef5 64#include "special.h"
398ef8ba 65#include "bus-errors.h"
d06dacd0 66#include "exit-status.h"
5dc4c17f 67#include "virt.h"
e96d6be7 68#include "watchdog.h"
b59e2465 69#include "cgroup-util.h"
9eb977db 70#include "path-util.h"
c1165f82 71#include "audit-fd.h"
60918275 72
701cc384
LP		 73/* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
74#define GC_QUEUE_ENTRIES_MAX 16
75
76/* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
94b6dfa2 77#define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
701cc384 78
8c47c732 79/* Where clients shall send notification messages to */
29252e9e 80#define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
8c47c732
LP		 81
82static int manager_setup_notify(Manager *m) {
83 union {
84 struct sockaddr sa;
85 struct sockaddr_un un;
86 } sa;
87 struct epoll_event ev;
29252e9e 88 int one = 1;
8c47c732
LP		 89
90 assert(m);
91
92 m->notify_watch.type = WATCH_NOTIFY;
29252e9e
LP		 93 m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
94 if (m->notify_watch.fd < 0) {
8c47c732
LP		 95 log_error("Failed to allocate notification socket: %m");
96 return -errno;
97 }
98
99 zero(sa);
100 sa.sa.sa_family = AF_UNIX;
101
31f92a7d 102 if (getpid() != 1 || detect_container(NULL) > 0)
29252e9e
LP		 103 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
104 else
105 strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
8c47c732 106
29252e9e 107 sa.un.sun_path[0] = 0;
1d6702e8 108
29252e9e 109 if (bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
8c47c732
LP		 110 log_error("bind() failed: %m");
111 return -errno;
112 }
113
114 if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
115 log_error("SO_PASSCRED failed: %m");
116 return -errno;
117 }
118
119 zero(ev);
120 ev.events = EPOLLIN;
121 ev.data.ptr = &m->notify_watch;
122
123 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
124 return -errno;
125
29252e9e
LP		 126 sa.un.sun_path[0] = '@';
127 m->notify_socket = strdup(sa.un.sun_path);
128 if (!m->notify_socket)
8c47c732
LP		 129 return -ENOMEM;
130
b2bb3dbe
LP		 131 log_debug("Using notification socket %s", m->notify_socket);
132
8c47c732
LP		 133 return 0;
134}
135
80876c20 136static int enable_special_signals(Manager *m) {
4466ee6a 137 int fd;
80876c20
LP		 138
139 assert(m);
140
a41b539e 141 /* Enable that we get SIGINT on control-alt-del. In containers
c9999773
LP		 142 * this will fail with EPERM (older) or EINVAL (newer), so
143 * ignore that. */
144 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
80876c20
LP		 145 log_warning("Failed to enable ctrl-alt-del handling: %m");
146
a41b539e
LP		 147 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
148 if (fd < 0) {
149 /* Support systems without virtual console */
150 if (fd != -ENOENT)
151 log_warning("Failed to open /dev/tty0: %m");
152 } else {
80876c20
LP		 153 /* Enable that we get SIGWINCH on kbrequest */
154 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
155 log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
156
157 close_nointr_nofail(fd);
158 }
159
160 return 0;
161}
162
ce578209 163static int manager_setup_signals(Manager *m) {
9152c765
LP		 164 sigset_t mask;
165 struct epoll_event ev;
57c0c30e 166 struct sigaction sa;
60918275 167
ce578209
LP		 168 assert(m);
169
57c0c30e
LP		 170 /* We are not interested in SIGSTOP and friends. */
171 zero(sa);
172 sa.sa_handler = SIG_DFL;
173 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
174 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
175
ce578209 176 assert_se(sigemptyset(&mask) == 0);
7d793605
LP		 177
178 sigset_add_many(&mask,
179 SIGCHLD, /* Child died */
180 SIGTERM, /* Reexecute daemon */
181 SIGHUP, /* Reload configuration */
182 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
183 SIGUSR2, /* systemd: dump status */
184 SIGINT, /* Kernel sends us this on control-alt-del */
185 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
186 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
187 SIGRTMIN+0, /* systemd: start default.target */
0003d1ab 188 SIGRTMIN+1, /* systemd: isolate rescue.target */
7d793605
LP		 189 SIGRTMIN+2, /* systemd: isolate emergency.target */
190 SIGRTMIN+3, /* systemd: start halt.target */
191 SIGRTMIN+4, /* systemd: start poweroff.target */
192 SIGRTMIN+5, /* systemd: start reboot.target */
0003d1ab
LP		 193 SIGRTMIN+6, /* systemd: start kexec.target */
194 SIGRTMIN+13, /* systemd: Immediate halt */
195 SIGRTMIN+14, /* systemd: Immediate poweroff */
196 SIGRTMIN+15, /* systemd: Immediate reboot */
197 SIGRTMIN+16, /* systemd: Immediate kexec */
0658666b
LP		 198 SIGRTMIN+20, /* systemd: enable status messages */
199 SIGRTMIN+21, /* systemd: disable status messages */
253ee27a
LP		 200 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
201 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
600b704e 202 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
4cfa2c99 203 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
253ee27a
LP		 204 SIGRTMIN+27, /* systemd: set log target to console */
205 SIGRTMIN+28, /* systemd: set log target to kmsg */
206 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
7d793605 207 -1);
ce578209
LP		 208 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
209
ef734fd6 210 m->signal_watch.type = WATCH_SIGNAL;
ce578209
LP		 211 if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
212 return -errno;
213
214 zero(ev);
215 ev.events = EPOLLIN;
216 ev.data.ptr = &m->signal_watch;
217
218 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
219 return -errno;
220
67445f4e 221 if (m->running_as == SYSTEMD_SYSTEM)
80876c20 222 return enable_special_signals(m);
e1414003 223
ce578209
LP		 224 return 0;
225}
226
71ecc858
LP		 227static void manager_strip_environment(Manager *m) {
228 assert(m);
229
230 /* Remove variables from the inherited set that are part of
231 * the container interface:
232 * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
233 strv_remove_prefix(m->environment, "container=");
234 strv_remove_prefix(m->environment, "container_");
235
236 /* Remove variables from the inherited set that are part of
237 * the initrd interface:
238 * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
239 strv_remove_prefix(m->environment, "RD_");
240}
241
67445f4e 242int manager_new(SystemdRunningAs running_as, Manager **_m) {
ce578209 243 Manager *m;
8e274523
LP		 244 int r = -ENOMEM;
245
246 assert(_m);
a5dab5ce 247 assert(running_as >= 0);
67445f4e 248 assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
ce578209 249
915b3753
LP		 250 m = new0(Manager, 1);
251 if (!m)
8e274523 252 return -ENOMEM;
60918275 253
915b3753 254 dual_timestamp_get(&m->userspace_timestamp);
e537352b 255
a5dab5ce 256 m->running_as = running_as;
cbd37330 257 m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
a16e1123 258 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
33be102a 259 m->pin_cgroupfs_fd = -1;
f2b68789 260 m->idle_pipe[0] = m->idle_pipe[1] = -1;
80876c20 261
4e434314 262 m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
ea430986 263 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
9152c765 264
71ecc858
LP		 265 m->environment = strv_copy(environ);
266 if (!m->environment)
1137a57c
LP		 267 goto fail;
268
71ecc858
LP		 269 manager_strip_environment(m);
270
67445f4e 271 if (running_as == SYSTEMD_SYSTEM) {
88f06645
LP		 272 m->default_controllers = strv_new("cpu", NULL);
273 if (!m->default_controllers)
274 goto fail;
275 }
06d4c99a 276
87f0e418 277 if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
60918275
LP		 278 goto fail;
279
280 if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
281 goto fail;
282
9152c765
LP		 283 if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
284 goto fail;
285
8e274523
LP		 286 if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
287 goto fail;
288
05e343b7
LP		 289 if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
290 goto fail;
291
9152c765
LP		 292 if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
293 goto fail;
294
8e274523
LP		 295 if ((r = manager_setup_signals(m)) < 0)
296 goto fail;
297
8e274523 298 if ((r = manager_setup_cgroup(m)) < 0)
9152c765
LP		 299 goto fail;
300
8c47c732
LP		 301 if ((r = manager_setup_notify(m)) < 0)
302 goto fail;
303
f278026d 304 /* Try to connect to the busses, if possible. */
67445f4e 305 if ((r = bus_init(m, running_as != SYSTEMD_SYSTEM)) < 0)
ea430986
LP		 306 goto fail;
307
72bc8d00
LP		 308 m->taint_usr = dir_is_empty("/usr") > 0;
309
8e274523
LP		 310 *_m = m;
311 return 0;
60918275
LP		 312
313fail:
314 manager_free(m);
8e274523 315 return r;
60918275
LP		 316}
317
23a177ef 318static unsigned manager_dispatch_cleanup_queue(Manager *m) {
595ed347 319 Unit *u;
23a177ef
LP		 320 unsigned n = 0;
321
322 assert(m);
323
595ed347
MS		 324 while ((u = m->cleanup_queue)) {
325 assert(u->in_cleanup_queue);
23a177ef 326
595ed347 327 unit_free(u);
23a177ef
LP		 328 n++;
329 }
330
331 return n;
332}
333
eced69b3 334enum {
35b8ca3a 335 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
eced69b3
LP		 336 GC_OFFSET_UNSURE, /* No clue */
337 GC_OFFSET_GOOD, /* We still need this unit */
338 GC_OFFSET_BAD, /* We don't need this unit anymore */
339 _GC_OFFSET_MAX
340};
341
342static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
701cc384
LP		 343 Iterator i;
344 Unit *other;
eced69b3 345 bool is_bad;
701cc384
LP		 346
347 assert(u);
348
ac155bb8
MS		 349 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
350 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
351 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
701cc384
LP		 352 return;
353
ac155bb8 354 if (u->in_cleanup_queue)
701cc384
LP		 355 goto bad;
356
357 if (unit_check_gc(u))
358 goto good;
359
ac155bb8 360 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
eced69b3
LP		 361
362 is_bad = true;
363
ac155bb8 364 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
701cc384
LP		 365 unit_gc_sweep(other, gc_marker);
366
ac155bb8 367 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
701cc384 368 goto good;
eced69b3 369
ac155bb8 370 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
eced69b3 371 is_bad = false;
701cc384
LP		 372 }
373
eced69b3
LP		 374 if (is_bad)
375 goto bad;
376
377 /* We were unable to find anything out about this entry, so
378 * let's investigate it later */
ac155bb8 379 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
eced69b3
LP		 380 unit_add_to_gc_queue(u);
381 return;
382
701cc384 383bad:
eced69b3
LP		 384 /* We definitely know that this one is not useful anymore, so
385 * let's mark it for deletion */
ac155bb8 386 u->gc_marker = gc_marker + GC_OFFSET_BAD;
eced69b3 387 unit_add_to_cleanup_queue(u);
701cc384
LP		 388 return;
389
390good:
ac155bb8 391 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
701cc384
LP		 392}
393
394static unsigned manager_dispatch_gc_queue(Manager *m) {
595ed347 395 Unit *u;
701cc384 396 unsigned n = 0;
eced69b3 397 unsigned gc_marker;
701cc384
LP		 398
399 assert(m);
400
401 if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
402 (m->gc_queue_timestamp <= 0 ||
403 (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
404 return 0;
405
406 log_debug("Running GC...");
407
eced69b3
LP		 408 m->gc_marker += _GC_OFFSET_MAX;
409 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
c9c0cadb 410 m->gc_marker = 1;
701cc384 411
eced69b3
LP		 412 gc_marker = m->gc_marker;
413
595ed347
MS		 414 while ((u = m->gc_queue)) {
415 assert(u->in_gc_queue);
701cc384 416
595ed347 417 unit_gc_sweep(u, gc_marker);
eced69b3 418
595ed347
MS		 419 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
420 u->in_gc_queue = false;
701cc384
LP		 421
422 n++;
423
595ed347
MS		 424 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
425 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
426 log_debug("Collecting %s", u->id);
427 u->gc_marker = gc_marker + GC_OFFSET_BAD;
428 unit_add_to_cleanup_queue(u);
701cc384
LP		 429 }
430 }
431
432 m->n_in_gc_queue = 0;
433 m->gc_queue_timestamp = 0;
434
435 return n;
436}
437
a16e1123 438static void manager_clear_jobs_and_units(Manager *m) {
a16e1123 439 Unit *u;
60918275
LP		 440
441 assert(m);
442
87f0e418
LP		 443 while ((u = hashmap_first(m->units)))
444 unit_free(u);
964e0949
LP		 445
446 manager_dispatch_cleanup_queue(m);
447
448 assert(!m->load_queue);
449 assert(!m->run_queue);
450 assert(!m->dbus_unit_queue);
451 assert(!m->dbus_job_queue);
452 assert(!m->cleanup_queue);
453 assert(!m->gc_queue);
454
964e0949
LP		 455 assert(hashmap_isempty(m->jobs));
456 assert(hashmap_isempty(m->units));
a16e1123
LP		 457}
458
459void manager_free(Manager *m) {
460 UnitType c;
c93ff2e9 461 int i;
87f0e418 462
a16e1123
LP		 463 assert(m);
464
465 manager_clear_jobs_and_units(m);
23a177ef 466
7824bbeb
LP		 467 for (c = 0; c < _UNIT_TYPE_MAX; c++)
468 if (unit_vtable[c]->shutdown)
469 unit_vtable[c]->shutdown(m);
470
a16e1123
LP		 471 /* If we reexecute ourselves, we keep the root cgroup
472 * around */
c6c18be3 473 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
8e274523 474
5a1e9937
LP		 475 manager_undo_generators(m);
476
5e8d1c9a 477 bus_done(m);
ea430986 478
87f0e418 479 hashmap_free(m->units);
60918275 480 hashmap_free(m->jobs);
9152c765 481 hashmap_free(m->watch_pids);
05e343b7 482 hashmap_free(m->watch_bus);
9152c765
LP		 483
484 if (m->epoll_fd >= 0)
a16e1123 485 close_nointr_nofail(m->epoll_fd);
acbb0225 486 if (m->signal_watch.fd >= 0)
a16e1123 487 close_nointr_nofail(m->signal_watch.fd);
8c47c732
LP		 488 if (m->notify_watch.fd >= 0)
489 close_nointr_nofail(m->notify_watch.fd);
60918275 490
c952c6ec
LP		 491 free(m->notify_socket);
492
84e3543e 493 lookup_paths_free(&m->lookup_paths);
1137a57c 494 strv_free(m->environment);
036643a2 495
06d4c99a
LP		 496 strv_free(m->default_controllers);
497
8e274523 498 hashmap_free(m->cgroup_bondings);
c6c18be3 499 set_free_free(m->unit_path_cache);
33be102a 500
f2b68789
LP		 501 close_pipe(m->idle_pipe);
502
664f88a7
LP		 503 free(m->switch_root);
504 free(m->switch_root_init);
505
c93ff2e9
FC		 506 for (i = 0; i < RLIMIT_NLIMITS; i++)
507 free(m->rlimit[i]);
508
60918275
LP		 509 free(m);
510}
511
a16e1123
LP		 512int manager_enumerate(Manager *m) {
513 int r = 0, q;
f50e0a01 514 UnitType c;
f50e0a01
LP		 515
516 assert(m);
517
a16e1123
LP		 518 /* Let's ask every type to load all units from disk/kernel
519 * that it might know */
f50e0a01
LP		 520 for (c = 0; c < _UNIT_TYPE_MAX; c++)
521 if (unit_vtable[c]->enumerate)
a16e1123
LP		 522 if ((q = unit_vtable[c]->enumerate(m)) < 0)
523 r = q;
f50e0a01
LP		 524
525 manager_dispatch_load_queue(m);
a16e1123
LP		 526 return r;
527}
528
529int manager_coldplug(Manager *m) {
530 int r = 0, q;
531 Iterator i;
532 Unit *u;
533 char *k;
534
535 assert(m);
f50e0a01
LP		 536
537 /* Then, let's set up their initial state. */
538 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
539
540 /* ignore aliases */
ac155bb8 541 if (u->id != k)
f50e0a01
LP		 542 continue;
543
cca098b0
LP		 544 if ((q = unit_coldplug(u)) < 0)
545 r = q;
f50e0a01
LP		 546 }
547
a16e1123
LP		 548 return r;
549}
550
fe51822e
LP		 551static void manager_build_unit_path_cache(Manager *m) {
552 char **i;
553 DIR *d = NULL;
554 int r;
555
556 assert(m);
557
558 set_free_free(m->unit_path_cache);
559
560 if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
561 log_error("Failed to allocate unit path cache.");
562 return;
563 }
564
565 /* This simply builds a list of files we know exist, so that
566 * we don't always have to go to disk */
567
568 STRV_FOREACH(i, m->lookup_paths.unit_path) {
569 struct dirent *de;
570
571 if (!(d = opendir(*i))) {
572 log_error("Failed to open directory: %m");
573 continue;
574 }
575
576 while ((de = readdir(d))) {
577 char *p;
578
579 if (ignore_file(de->d_name))
580 continue;
581
b7def684 582 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
44d91056 583 if (!p) {
fe51822e
LP		 584 r = -ENOMEM;
585 goto fail;
586 }
587
588 if ((r = set_put(m->unit_path_cache, p)) < 0) {
589 free(p);
590 goto fail;
591 }
592 }
593
594 closedir(d);
595 d = NULL;
596 }
597
598 return;
599
600fail:
601 log_error("Failed to build unit path cache: %s", strerror(-r));
602
603 set_free_free(m->unit_path_cache);
604 m->unit_path_cache = NULL;
605
606 if (d)
607 closedir(d);
608}
609
a16e1123
LP		 610int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
611 int r, q;
612
613 assert(m);
614
5a1e9937
LP		 615 manager_run_generators(m);
616
07719a21
LP		 617 r = lookup_paths_init(
618 &m->lookup_paths, m->running_as, true,
619 m->generator_unit_path,
620 m->generator_unit_path_early,
621 m->generator_unit_path_late);
622 if (r < 0)
623 return r;
624
fe51822e
LP		 625 manager_build_unit_path_cache(m);
626
9f611ad8
LP		 627 /* If we will deserialize make sure that during enumeration
628 * this is already known, so we increase the counter here
629 * already */
630 if (serialization)
a7556052 631 m->n_reloading ++;
9f611ad8 632
a16e1123
LP		 633 /* First, enumerate what we can from all config files */
634 r = manager_enumerate(m);
635
636 /* Second, deserialize if there is something to deserialize */
07719a21
LP		 637 if (serialization) {
638 q = manager_deserialize(m, serialization, fds);
639 if (q < 0)
a16e1123 640 r = q;
07719a21 641 }
a16e1123
LP		 642
643 /* Third, fire things up! */
07719a21
LP		 644 q = manager_coldplug(m);
645 if (q < 0)
a16e1123
LP		 646 r = q;
647
9f611ad8 648 if (serialization) {
a7556052
LP		 649 assert(m->n_reloading > 0);
650 m->n_reloading --;
9f611ad8
LP		 651 }
652
a16e1123 653 return r;
f50e0a01
LP		 654}
655
398ef8ba 656int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
e5b5ae50 657 int r;
7527cb52 658 Transaction *tr;
e5b5ae50
LP		 659
660 assert(m);
661 assert(type < _JOB_TYPE_MAX);
87f0e418 662 assert(unit);
e5b5ae50 663 assert(mode < _JOB_MODE_MAX);
60918275 664
398ef8ba
LP		 665 if (mode == JOB_ISOLATE && type != JOB_START) {
666 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
c497c7a9 667 return -EINVAL;
398ef8ba 668 }
c497c7a9 669
ac155bb8 670 if (mode == JOB_ISOLATE && !unit->allow_isolate) {
2528a7a6
LP		 671 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
672 return -EPERM;
673 }
674
ac155bb8 675 log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
9f04bd52 676
e0209d83
MS		 677 job_type_collapse(&type, unit);
678
7527cb52
MS		 679 tr = transaction_new();
680 if (!tr)
681 return -ENOMEM;
11dd41ce 682
7527cb52
MS		 683 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
684 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
b94fbd30 685 mode == JOB_IGNORE_DEPENDENCIES, e);
7527cb52
MS		 686 if (r < 0)
687 goto tr_abort;
c497c7a9 688
7527cb52
MS		 689 if (mode == JOB_ISOLATE) {
690 r = transaction_add_isolate_jobs(tr, m);
691 if (r < 0)
692 goto tr_abort;
693 }
694
695 r = transaction_activate(tr, m, mode, e);
696 if (r < 0)
697 goto tr_abort;
e5b5ae50 698
b94fbd30 699 log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
f50e0a01 700
e5b5ae50 701 if (_ret)
b94fbd30 702 *_ret = tr->anchor_job;
60918275 703
7527cb52 704 transaction_free(tr);
e5b5ae50 705 return 0;
7527cb52
MS		 706
707tr_abort:
708 transaction_abort(tr);
709 transaction_free(tr);
710 return r;
e5b5ae50 711}
60918275 712
398ef8ba 713int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
28247076
LP		 714 Unit *unit;
715 int r;
716
717 assert(m);
718 assert(type < _JOB_TYPE_MAX);
719 assert(name);
720 assert(mode < _JOB_MODE_MAX);
721
c3090674
LP		 722 r = manager_load_unit(m, name, NULL, NULL, &unit);
723 if (r < 0)
28247076
LP		 724 return r;
725
398ef8ba 726 return manager_add_job(m, type, unit, mode, override, e, _ret);
28247076
LP		 727}
728
60918275
LP		 729Job *manager_get_job(Manager *m, uint32_t id) {
730 assert(m);
731
732 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
733}
734
87f0e418 735Unit *manager_get_unit(Manager *m, const char *name) {
60918275
LP		 736 assert(m);
737 assert(name);
738
87f0e418 739 return hashmap_get(m->units, name);
60918275
LP		 740}
741
c1e1601e 742unsigned manager_dispatch_load_queue(Manager *m) {
595ed347 743 Unit *u;
c1e1601e 744 unsigned n = 0;
60918275
LP		 745
746 assert(m);
747
223dabab
LP		 748 /* Make sure we are not run recursively */
749 if (m->dispatching_load_queue)
c1e1601e 750 return 0;
223dabab
LP		 751
752 m->dispatching_load_queue = true;
753
87f0e418 754 /* Dispatches the load queue. Takes a unit from the queue and
60918275
LP		 755 * tries to load its data until the queue is empty */
756
595ed347
MS		 757 while ((u = m->load_queue)) {
758 assert(u->in_load_queue);
034c6ed7 759
595ed347 760 unit_load(u);
c1e1601e 761 n++;
60918275
LP		 762 }
763
223dabab 764 m->dispatching_load_queue = false;
c1e1601e 765 return n;
60918275
LP		 766}
767
398ef8ba 768int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
87f0e418 769 Unit *ret;
7d17cfbc 770 UnitType t;
60918275
LP		 771 int r;
772
773 assert(m);
9e2f7c11 774 assert(name || path);
60918275 775
db06e3b6
LP		 776 /* This will prepare the unit for loading, but not actually
777 * load anything from disk. */
0301abf4 778
398ef8ba
LP		 779 if (path && !is_path(path)) {
780 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
9e2f7c11 781 return -EINVAL;
398ef8ba 782 }
9e2f7c11
LP		 783
784 if (!name)
9eb977db 785 name = path_get_file_name(path);
9e2f7c11 786
7d17cfbc
MS		 787 t = unit_name_to_type(name);
788
5f739699 789 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
398ef8ba 790 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
9e2f7c11 791 return -EINVAL;
398ef8ba 792 }
60918275 793
7d17cfbc
MS		 794 ret = manager_get_unit(m, name);
795 if (ret) {
034c6ed7 796 *_ret = ret;
413d6313 797 return 1;
034c6ed7 798 }
60918275 799
7d17cfbc
MS		 800 ret = unit_new(m, unit_vtable[t]->object_size);
801 if (!ret)
60918275
LP		 802 return -ENOMEM;
803
7d17cfbc 804 if (path) {
ac155bb8
MS		 805 ret->fragment_path = strdup(path);
806 if (!ret->fragment_path) {
0301abf4
LP		 807 unit_free(ret);
808 return -ENOMEM;
809 }
7d17cfbc 810 }
0301abf4 811
87f0e418
LP		 812 if ((r = unit_add_name(ret, name)) < 0) {
813 unit_free(ret);
1ffba6fe 814 return r;
60918275
LP		 815 }
816
87f0e418 817 unit_add_to_load_queue(ret);
c1e1601e 818 unit_add_to_dbus_queue(ret);
949061f0 819 unit_add_to_gc_queue(ret);
c1e1601e 820
db06e3b6
LP		 821 if (_ret)
822 *_ret = ret;
823
824 return 0;
825}
826
398ef8ba 827int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
db06e3b6
LP		 828 int r;
829
830 assert(m);
831
832 /* This will load the service information files, but not actually
833 * start any services or anything. */
834
c3090674
LP		 835 r = manager_load_unit_prepare(m, name, path, e, _ret);
836 if (r != 0)
db06e3b6
LP		 837 return r;
838
f50e0a01 839 manager_dispatch_load_queue(m);
60918275 840
9e2f7c11 841 if (_ret)
413d6313 842 *_ret = unit_follow_merge(*_ret);
9e2f7c11 843
60918275
LP		 844 return 0;
845}
a66d02c3 846
cea8e32e 847void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
034c6ed7 848 Iterator i;
a66d02c3
LP		 849 Job *j;
850
851 assert(s);
852 assert(f);
853
034c6ed7 854 HASHMAP_FOREACH(j, s->jobs, i)
cea8e32e 855 job_dump(j, f, prefix);
a66d02c3
LP		 856}
857
87f0e418 858void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
034c6ed7 859 Iterator i;
87f0e418 860 Unit *u;
11dd41ce 861 const char *t;
a66d02c3
LP		 862
863 assert(s);
864 assert(f);
865
87f0e418 866 HASHMAP_FOREACH_KEY(u, t, s->units, i)
ac155bb8 867 if (u->id == t)
87f0e418 868 unit_dump(u, f, prefix);
a66d02c3 869}
7fad411c
LP		 870
871void manager_clear_jobs(Manager *m) {
872 Job *j;
873
874 assert(m);
875
7fad411c 876 while ((j = hashmap_first(m->jobs)))
5273510e
MS		 877 /* No need to recurse. We're cancelling all jobs. */
878 job_finish_and_invalidate(j, JOB_CANCELED, false);
7fad411c 879}
83c60c9f 880
c1e1601e 881unsigned manager_dispatch_run_queue(Manager *m) {
83c60c9f 882 Job *j;
c1e1601e 883 unsigned n = 0;
83c60c9f 884
034c6ed7 885 if (m->dispatching_run_queue)
c1e1601e 886 return 0;
034c6ed7
LP		 887
888 m->dispatching_run_queue = true;
9152c765 889
034c6ed7 890 while ((j = m->run_queue)) {
ac1135be 891 assert(j->installed);
034c6ed7
LP		 892 assert(j->in_run_queue);
893
894 job_run_and_invalidate(j);
c1e1601e 895 n++;
9152c765 896 }
034c6ed7
LP		 897
898 m->dispatching_run_queue = false;
c1e1601e
LP		 899 return n;
900}
901
902unsigned manager_dispatch_dbus_queue(Manager *m) {
903 Job *j;
595ed347 904 Unit *u;
c1e1601e
LP		 905 unsigned n = 0;
906
907 assert(m);
908
909 if (m->dispatching_dbus_queue)
910 return 0;
911
912 m->dispatching_dbus_queue = true;
913
595ed347
MS		 914 while ((u = m->dbus_unit_queue)) {
915 assert(u->in_dbus_queue);
c1e1601e 916
595ed347 917 bus_unit_send_change_signal(u);
c1e1601e
LP		 918 n++;
919 }
920
921 while ((j = m->dbus_job_queue)) {
922 assert(j->in_dbus_queue);
923
924 bus_job_send_change_signal(j);
925 n++;
926 }
927
928 m->dispatching_dbus_queue = false;
929 return n;
9152c765
LP		 930}
931
8c47c732
LP		 932static int manager_process_notify_fd(Manager *m) {
933 ssize_t n;
934
935 assert(m);
936
937 for (;;) {
938 char buf[4096];
939 struct msghdr msghdr;
940 struct iovec iovec;
941 struct ucred *ucred;
942 union {
943 struct cmsghdr cmsghdr;
944 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
945 } control;
946 Unit *u;
947 char **tags;
948
949 zero(iovec);
950 iovec.iov_base = buf;
951 iovec.iov_len = sizeof(buf)-1;
952
953 zero(control);
954 zero(msghdr);
955 msghdr.msg_iov = &iovec;
956 msghdr.msg_iovlen = 1;
957 msghdr.msg_control = &control;
958 msghdr.msg_controllen = sizeof(control);
959
960 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
961 if (n >= 0)
962 return -EIO;
963
f6144808 964 if (errno == EAGAIN || errno == EINTR)
8c47c732
LP		 965 break;
966
967 return -errno;
968 }
969
970 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
971 control.cmsghdr.cmsg_level != SOL_SOCKET ||
972 control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
973 control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
974 log_warning("Received notify message without credentials. Ignoring.");
975 continue;
976 }
977
978 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
979
c6c18be3 980 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
8c47c732
LP		 981 if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
982 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
983 continue;
984 }
985
8c40acf7
LP		 986 assert((size_t) n < sizeof(buf));
987 buf[n] = 0;
8c47c732
LP		 988 if (!(tags = strv_split(buf, "\n\r")))
989 return -ENOMEM;
990
ac155bb8 991 log_debug("Got notification message for unit %s", u->id);
8c47c732
LP		 992
993 if (UNIT_VTABLE(u)->notify_message)
c952c6ec 994 UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
8c47c732
LP		 995
996 strv_free(tags);
997 }
998
999 return 0;
1000}
1001
034c6ed7 1002static int manager_dispatch_sigchld(Manager *m) {
9152c765
LP		 1003 assert(m);
1004
1005 for (;;) {
1006 siginfo_t si;
87f0e418 1007 Unit *u;
8c47c732 1008 int r;
9152c765
LP		 1009
1010 zero(si);
4112df16
LP		 1011
1012 /* First we call waitd() for a PID and do not reap the
1013 * zombie. That way we can still access /proc/$PID for
1014 * it while it is a zombie. */
1015 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
acbb0225
LP		 1016
1017 if (errno == ECHILD)
1018 break;
1019
4112df16
LP		 1020 if (errno == EINTR)
1021 continue;
1022
9152c765 1023 return -errno;
acbb0225 1024 }
9152c765 1025
4112df16 1026 if (si.si_pid <= 0)
9152c765
LP		 1027 break;
1028
15d5d9d9 1029 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
4112df16
LP		 1030 char *name = NULL;
1031
87d2c1ff 1032 get_process_comm(si.si_pid, &name);
bb00e604 1033 log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
4112df16
LP		 1034 free(name);
1035 }
1036
8c47c732
LP		 1037 /* Let's flush any message the dying child might still
1038 * have queued for us. This ensures that the process
1039 * still exists in /proc so that we can figure out
1040 * which cgroup and hence unit it belongs to. */
1041 if ((r = manager_process_notify_fd(m)) < 0)
1042 return r;
1043
1044 /* And now figure out the unit this belongs to */
c6c18be3 1045 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
8c47c732
LP		 1046 u = cgroup_unit_by_pid(m, si.si_pid);
1047
4112df16
LP		 1048 /* And now, we actually reap the zombie. */
1049 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1050 if (errno == EINTR)
1051 continue;
1052
1053 return -errno;
1054 }
1055
034c6ed7
LP		 1056 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1057 continue;
1058
bb00e604
LP		 1059 log_debug("Child %lu died (code=%s, status=%i/%s)",
1060 (long unsigned) si.si_pid,
4112df16
LP		 1061 sigchld_code_to_string(si.si_code),
1062 si.si_status,
d06dacd0
LP		 1063 strna(si.si_code == CLD_EXITED
1064 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1065 : signal_to_string(si.si_status)));
acbb0225 1066
8c47c732 1067 if (!u)
9152c765
LP		 1068 continue;
1069
ac155bb8 1070 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
6c1a0478 1071
c6c18be3 1072 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
87f0e418 1073 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
9152c765
LP		 1074 }
1075
1076 return 0;
1077}
1078
7d793605 1079static int manager_start_target(Manager *m, const char *name, JobMode mode) {
28247076 1080 int r;
398ef8ba
LP		 1081 DBusError error;
1082
1083 dbus_error_init(&error);
1084
af2d49f7 1085 log_debug("Activating special unit %s", name);
1e001f52 1086
398ef8ba
LP		 1087 if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1088 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
28247076 1089
398ef8ba 1090 dbus_error_free(&error);
a1b256b0
LP		 1091
1092 return r;
28247076
LP		 1093}
1094
a16e1123 1095static int manager_process_signal_fd(Manager *m) {
9152c765
LP		 1096 ssize_t n;
1097 struct signalfd_siginfo sfsi;
1098 bool sigchld = false;
1099
1100 assert(m);
1101
1102 for (;;) {
acbb0225 1103 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
9152c765
LP		 1104
1105 if (n >= 0)
1106 return -EIO;
1107
63090775 1108 if (errno == EINTR || errno == EAGAIN)
acbb0225 1109 break;
9152c765
LP		 1110
1111 return -errno;
1112 }
1113
67370238
LP		 1114 if (sfsi.ssi_pid > 0) {
1115 char *p = NULL;
1116
87d2c1ff 1117 get_process_comm(sfsi.ssi_pid, &p);
dfa7f7e1 1118
67370238 1119 log_debug("Received SIG%s from PID %lu (%s).",
4e240ab0 1120 signal_to_string(sfsi.ssi_signo),
67370238
LP		 1121 (unsigned long) sfsi.ssi_pid, strna(p));
1122 free(p);
1123 } else
4e240ab0 1124 log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1e001f52 1125
b9cd2ec1
LP		 1126 switch (sfsi.ssi_signo) {
1127
4112df16 1128 case SIGCHLD:
9152c765 1129 sigchld = true;
b9cd2ec1
LP		 1130 break;
1131
6632c602 1132 case SIGTERM:
67445f4e 1133 if (m->running_as == SYSTEMD_SYSTEM) {
db06e3b6
LP		 1134 /* This is for compatibility with the
1135 * original sysvinit */
e11dc4a2 1136 m->exit_code = MANAGER_REEXECUTE;
a1b256b0
LP		 1137 break;
1138 }
84e9af1e 1139
a1b256b0 1140 /* Fall through */
e11dc4a2
LP		 1141
1142 case SIGINT:
67445f4e 1143 if (m->running_as == SYSTEMD_SYSTEM) {
7d793605 1144 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
84e9af1e
LP		 1145 break;
1146 }
1147
a1b256b0 1148 /* Run the exit target if there is one, if not, just exit. */
0003d1ab 1149 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
a1b256b0
LP		 1150 m->exit_code = MANAGER_EXIT;
1151 return 0;
1152 }
1153
1154 break;
84e9af1e 1155
28247076 1156 case SIGWINCH:
67445f4e 1157 if (m->running_as == SYSTEMD_SYSTEM)
7d793605 1158 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
84e9af1e 1159
28247076
LP		 1160 /* This is a nop on non-init */
1161 break;
84e9af1e 1162
28247076 1163 case SIGPWR:
67445f4e 1164 if (m->running_as == SYSTEMD_SYSTEM)
7d793605 1165 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
84e9af1e 1166
28247076 1167 /* This is a nop on non-init */
84e9af1e 1168 break;
6632c602 1169
1005d14f 1170 case SIGUSR1: {
57ee42ce
LP		 1171 Unit *u;
1172
1173 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1174
1175 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1176 log_info("Trying to reconnect to bus...");
3996fbe2 1177 bus_init(m, true);
57ee42ce
LP		 1178 }
1179
1180 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1181 log_info("Loading D-Bus service...");
7d793605 1182 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
57ee42ce
LP		 1183 }
1184
1185 break;
1186 }
1187
2149e37c
LP		 1188 case SIGUSR2: {
1189 FILE *f;
1190 char *dump = NULL;
1191 size_t size;
1192
1193 if (!(f = open_memstream(&dump, &size))) {
1194 log_warning("Failed to allocate memory stream.");
1195 break;
1196 }
1197
1198 manager_dump_units(m, f, "\t");
1199 manager_dump_jobs(m, f, "\t");
1200
1201 if (ferror(f)) {
1202 fclose(f);
1203 free(dump);
1204 log_warning("Failed to write status stream");
1205 break;
1206 }
1207
1208 fclose(f);
1209 log_dump(LOG_INFO, dump);
1210 free(dump);
1211
1005d14f 1212 break;
2149e37c 1213 }
1005d14f 1214
a16e1123
LP		 1215 case SIGHUP:
1216 m->exit_code = MANAGER_RELOAD;
1217 break;
1218
7d793605 1219 default: {
253ee27a 1220
0003d1ab
LP		 1221 /* Starting SIGRTMIN+0 */
1222 static const char * const target_table[] = {
7d793605
LP		 1223 [0] = SPECIAL_DEFAULT_TARGET,
1224 [1] = SPECIAL_RESCUE_TARGET,
f057408c 1225 [2] = SPECIAL_EMERGENCY_TARGET,
7d793605
LP		 1226 [3] = SPECIAL_HALT_TARGET,
1227 [4] = SPECIAL_POWEROFF_TARGET,
0003d1ab
LP		 1228 [5] = SPECIAL_REBOOT_TARGET,
1229 [6] = SPECIAL_KEXEC_TARGET
1230 };
1231
1232 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1233 static const ManagerExitCode code_table[] = {
1234 [0] = MANAGER_HALT,
1235 [1] = MANAGER_POWEROFF,
1236 [2] = MANAGER_REBOOT,
1237 [3] = MANAGER_KEXEC
7d793605
LP		 1238 };
1239
1240 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
0003d1ab 1241 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
764e9b5f
MS		 1242 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1243 manager_start_target(m, target_table[idx],
1244 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
7d793605
LP		 1245 break;
1246 }
1247
0003d1ab
LP		 1248 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1249 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1250 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1251 break;
1252 }
1253
0658666b
LP		 1254 switch (sfsi.ssi_signo - SIGRTMIN) {
1255
1256 case 20:
1257 log_debug("Enabling showing of status.");
27d340c7 1258 manager_set_show_status(m, true);
0658666b
LP		 1259 break;
1260
1261 case 21:
1262 log_debug("Disabling showing of status.");
27d340c7 1263 manager_set_show_status(m, false);
0658666b
LP		 1264 break;
1265
253ee27a
LP		 1266 case 22:
1267 log_set_max_level(LOG_DEBUG);
1268 log_notice("Setting log level to debug.");
1269 break;
1270
1271 case 23:
1272 log_set_max_level(LOG_INFO);
1273 log_notice("Setting log level to info.");
1274 break;
1275
600b704e
LP		 1276 case 24:
1277 if (m->running_as == SYSTEMD_USER) {
1278 m->exit_code = MANAGER_EXIT;
1279 return 0;
1280 }
1281
1282 /* This is a nop on init */
1283 break;
1284
4cfa2c99
LP		 1285 case 26:
1286 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1287 log_notice("Setting log target to journal-or-kmsg.");
1288 break;
1289
253ee27a
LP		 1290 case 27:
1291 log_set_target(LOG_TARGET_CONSOLE);
1292 log_notice("Setting log target to console.");
1293 break;
1294
1295 case 28:
1296 log_set_target(LOG_TARGET_KMSG);
1297 log_notice("Setting log target to kmsg.");
1298 break;
1299
1300 case 29:
1301 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1302 log_notice("Setting log target to syslog-or-kmsg.");
1303 break;
1304
0658666b 1305 default:
4e240ab0 1306 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
0658666b 1307 }
b9cd2ec1 1308 }
7d793605 1309 }
9152c765
LP		 1310 }
1311
1312 if (sigchld)
034c6ed7
LP		 1313 return manager_dispatch_sigchld(m);
1314
1315 return 0;
1316}
1317
a16e1123 1318static int process_event(Manager *m, struct epoll_event *ev) {
034c6ed7 1319 int r;
acbb0225 1320 Watch *w;
034c6ed7
LP		 1321
1322 assert(m);
1323 assert(ev);
1324
3df5bf61 1325 assert_se(w = ev->data.ptr);
034c6ed7 1326
40dde66f
LP		 1327 if (w->type == WATCH_INVALID)
1328 return 0;
1329
acbb0225 1330 switch (w->type) {
034c6ed7 1331
ef734fd6 1332 case WATCH_SIGNAL:
034c6ed7 1333
acbb0225 1334 /* An incoming signal? */
f94ea366 1335 if (ev->events != EPOLLIN)
acbb0225 1336 return -EINVAL;
034c6ed7 1337
a16e1123 1338 if ((r = manager_process_signal_fd(m)) < 0)
acbb0225 1339 return r;
034c6ed7 1340
acbb0225 1341 break;
034c6ed7 1342
8c47c732
LP		 1343 case WATCH_NOTIFY:
1344
1345 /* An incoming daemon notification event? */
1346 if (ev->events != EPOLLIN)
1347 return -EINVAL;
1348
1349 if ((r = manager_process_notify_fd(m)) < 0)
1350 return r;
1351
1352 break;
1353
acbb0225 1354 case WATCH_FD:
034c6ed7 1355
acbb0225 1356 /* Some fd event, to be dispatched to the units */
ea430986 1357 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
acbb0225 1358 break;
034c6ed7 1359
faf919f1
LP		 1360 case WATCH_UNIT_TIMER:
1361 case WATCH_JOB_TIMER: {
acbb0225
LP		 1362 uint64_t v;
1363 ssize_t k;
034c6ed7 1364
acbb0225 1365 /* Some timer event, to be dispatched to the units */
68b29a9f
LP		 1366 k = read(w->fd, &v, sizeof(v));
1367 if (k != sizeof(v)) {
034c6ed7 1368
acbb0225
LP		 1369 if (k < 0 && (errno == EINTR || errno == EAGAIN))
1370 break;
034c6ed7 1371
acbb0225 1372 return k < 0 ? -errno : -EIO;
034c6ed7
LP		 1373 }
1374
faf919f1
LP		 1375 if (w->type == WATCH_UNIT_TIMER)
1376 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1377 else
1378 job_timer_event(w->data.job, v, w);
acbb0225
LP		 1379 break;
1380 }
1381
ef734fd6
LP		 1382 case WATCH_MOUNT:
1383 /* Some mount table change, intended for the mount subsystem */
1384 mount_fd_event(m, ev->events);
1385 break;
1386
4e434314
LP		 1387 case WATCH_SWAP:
1388 /* Some swap table change, intended for the swap subsystem */
1389 swap_fd_event(m, ev->events);
1390 break;
1391
f94ea366
LP		 1392 case WATCH_UDEV:
1393 /* Some notification from udev, intended for the device subsystem */
1394 device_fd_event(m, ev->events);
1395 break;
1396
ea430986
LP		 1397 case WATCH_DBUS_WATCH:
1398 bus_watch_event(m, w, ev->events);
1399 break;
1400
1401 case WATCH_DBUS_TIMEOUT:
1402 bus_timeout_event(m, w, ev->events);
1403 break;
1404
acbb0225 1405 default:
c5fd1e57 1406 log_error("event type=%i", w->type);
acbb0225 1407 assert_not_reached("Unknown epoll event type.");
034c6ed7 1408 }
9152c765
LP		 1409
1410 return 0;
1411}
1412
1413int manager_loop(Manager *m) {
1414 int r;
9152c765 1415
fac9f8df 1416 RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
ea430986 1417
9152c765 1418 assert(m);
a16e1123 1419 m->exit_code = MANAGER_RUNNING;
9152c765 1420
fe51822e
LP		 1421 /* Release the path cache */
1422 set_free_free(m->unit_path_cache);
1423 m->unit_path_cache = NULL;
1424
b0c918b9
LP		 1425 manager_check_finished(m);
1426
a4312405
LP		 1427 /* There might still be some zombies hanging around from
1428 * before we were exec()'ed. Leat's reap them */
e96d6be7
LP		 1429 r = manager_dispatch_sigchld(m);
1430 if (r < 0)
a4312405
LP		 1431 return r;
1432
a16e1123 1433 while (m->exit_code == MANAGER_RUNNING) {
957ca890
LP		 1434 struct epoll_event event;
1435 int n;
c757a65b 1436 int wait_msec = -1;
9152c765 1437
67445f4e 1438 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
e96d6be7
LP		 1439 watchdog_ping();
1440
ea430986
LP		 1441 if (!ratelimit_test(&rl)) {
1442 /* Yay, something is going seriously wrong, pause a little */
1443 log_warning("Looping too fast. Throttling execution a little.");
1444 sleep(1);
e96d6be7 1445 continue;
ea430986
LP		 1446 }
1447
37a8e683 1448 if (manager_dispatch_load_queue(m) > 0)
23a177ef
LP		 1449 continue;
1450
37a8e683 1451 if (manager_dispatch_run_queue(m) > 0)
701cc384
LP		 1452 continue;
1453
37a8e683 1454 if (bus_dispatch(m) > 0)
c1e1601e 1455 continue;
034c6ed7 1456
37a8e683 1457 if (manager_dispatch_cleanup_queue(m) > 0)
c1e1601e
LP		 1458 continue;
1459
37a8e683 1460 if (manager_dispatch_gc_queue(m) > 0)
c1e1601e
LP		 1461 continue;
1462
1463 if (manager_dispatch_dbus_queue(m) > 0)
ea430986 1464 continue;
ea430986 1465
e04aad61
LP		 1466 if (swap_dispatch_reload(m) > 0)
1467 continue;
1468
c757a65b 1469 /* Sleep for half the watchdog time */
67445f4e 1470 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
c757a65b
LP		 1471 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1472 if (wait_msec <= 0)
1473 wait_msec = 1;
1474 } else
1475 wait_msec = -1;
1476
e96d6be7
LP		 1477 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1478 if (n < 0) {
9152c765 1479
6089f4a9 1480 if (errno == EINTR)
9152c765
LP		 1481 continue;
1482
1483 return -errno;
e96d6be7
LP		 1484 } else if (n == 0)
1485 continue;
9152c765 1486
957ca890 1487 assert(n == 1);
b9cd2ec1 1488
e96d6be7
LP		 1489 r = process_event(m, &event);
1490 if (r < 0)
957ca890 1491 return r;
a16e1123 1492 }
957ca890 1493
a16e1123 1494 return m->exit_code;
83c60c9f 1495}
ea430986 1496
80fbf05e 1497int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
ea430986
LP		 1498 char *n;
1499 Unit *u;
80fbf05e 1500 int r;
ea430986
LP		 1501
1502 assert(m);
1503 assert(s);
1504 assert(_u);
1505
1506 if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1507 return -EINVAL;
1508
80fbf05e
MS		 1509 n = bus_path_unescape(s+31);
1510 if (!n)
ea430986
LP		 1511 return -ENOMEM;
1512
80fbf05e 1513 r = manager_load_unit(m, n, NULL, e, &u);
ea430986
LP		 1514 free(n);
1515
80fbf05e
MS		 1516 if (r < 0)
1517 return r;
ea430986
LP		 1518
1519 *_u = u;
1520
1521 return 0;
1522}
86fbf370
LP		 1523
1524int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1525 Job *j;
1526 unsigned id;
1527 int r;
1528
1529 assert(m);
1530 assert(s);
1531 assert(_j);
1532
1533 if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1534 return -EINVAL;
1535
1536 if ((r = safe_atou(s + 30, &id)) < 0)
1537 return r;
1538
1539 if (!(j = manager_get_job(m, id)))
1540 return -ENOENT;
1541
1542 *_j = j;
1543
1544 return 0;
1545}
dfcd764e 1546
4927fcae 1547void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
e537352b 1548
4927fcae
LP		 1549#ifdef HAVE_AUDIT
1550 char *p;
c1165f82 1551 int audit_fd;
e537352b 1552
c1165f82
LP		 1553 audit_fd = get_audit_fd();
1554 if (audit_fd < 0)
e537352b
LP		 1555 return;
1556
bbd3a7ba
LP		 1557 /* Don't generate audit events if the service was already
1558 * started and we're just deserializing */
a7556052 1559 if (m->n_reloading > 0)
bbd3a7ba
LP		 1560 return;
1561
67445f4e 1562 if (m->running_as != SYSTEMD_SYSTEM)
f1dd0c3f
LP		 1563 return;
1564
ac155bb8 1565 if (u->type != UNIT_SERVICE)
f1dd0c3f
LP		 1566 return;
1567
ac155bb8 1568 if (!(p = unit_name_to_prefix_and_instance(u->id))) {
4927fcae 1569 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
e537352b
LP		 1570 return;
1571 }
1572
c1165f82 1573 if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
391ade86
LP		 1574 if (errno == EPERM) {
1575 /* We aren't allowed to send audit messages?
44785992 1576 * Then let's not retry again. */
c1165f82 1577 close_audit_fd();
44785992
LP		 1578 } else
1579 log_warning("Failed to send audit message: %m");
391ade86 1580 }
e537352b 1581
4927fcae
LP		 1582 free(p);
1583#endif
e537352b 1584
e537352b
LP		 1585}
1586
e983b760
LP		 1587void manager_send_unit_plymouth(Manager *m, Unit *u) {
1588 int fd = -1;
1589 union sockaddr_union sa;
1590 int n = 0;
1591 char *message = NULL;
e983b760
LP		 1592
1593 /* Don't generate plymouth events if the service was already
1594 * started and we're just deserializing */
a7556052 1595 if (m->n_reloading > 0)
e983b760
LP		 1596 return;
1597
67445f4e 1598 if (m->running_as != SYSTEMD_SYSTEM)
e983b760
LP		 1599 return;
1600
ac155bb8
MS		 1601 if (u->type != UNIT_SERVICE &&
1602 u->type != UNIT_MOUNT &&
1603 u->type != UNIT_SWAP)
e983b760
LP		 1604 return;
1605
1606 /* We set SOCK_NONBLOCK here so that we rather drop the
1607 * message then wait for plymouth */
1608 if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1609 log_error("socket() failed: %m");
1610 return;
1611 }
1612
1613 zero(sa);
1614 sa.sa.sa_family = AF_UNIX;
96707269
LP		 1615 strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1616 if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
e983b760
LP		 1617
1618 if (errno != EPIPE &&
1619 errno != EAGAIN &&
1620 errno != ENOENT &&
1621 errno != ECONNREFUSED &&
1622 errno != ECONNRESET &&
1623 errno != ECONNABORTED)
1624 log_error("connect() failed: %m");
1625
1626 goto finish;
1627 }
1628
ac155bb8 1629 if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
0d0f0c50 1630 log_oom();
e983b760
LP		 1631 goto finish;
1632 }
1633
1634 errno = 0;
bd40a2d8 1635 if (write(fd, message, n + 1) != n + 1) {
e983b760
LP		 1636
1637 if (errno != EPIPE &&
1638 errno != EAGAIN &&
1639 errno != ENOENT &&
1640 errno != ECONNREFUSED &&
1641 errno != ECONNRESET &&
1642 errno != ECONNABORTED)
1643 log_error("Failed to write Plymouth message: %m");
1644
1645 goto finish;
1646 }
1647
1648finish:
1649 if (fd >= 0)
1650 close_nointr_nofail(fd);
1651
1652 free(message);
1653}
1654
05e343b7
LP		 1655void manager_dispatch_bus_name_owner_changed(
1656 Manager *m,
1657 const char *name,
1658 const char* old_owner,
1659 const char *new_owner) {
1660
1661 Unit *u;
1662
1663 assert(m);
1664 assert(name);
1665
1666 if (!(u = hashmap_get(m->watch_bus, name)))
1667 return;
1668
1669 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1670}
1671
1672void manager_dispatch_bus_query_pid_done(
1673 Manager *m,
1674 const char *name,
1675 pid_t pid) {
1676
1677 Unit *u;
1678
1679 assert(m);
1680 assert(name);
1681 assert(pid >= 1);
1682
1683 if (!(u = hashmap_get(m->watch_bus, name)))
1684 return;
1685
1686 UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1687}
1688
d8d5ab98 1689int manager_open_serialization(Manager *m, FILE **_f) {
b925e726 1690 char *path = NULL;
a16e1123
LP		 1691 mode_t saved_umask;
1692 int fd;
1693 FILE *f;
1694
1695 assert(_f);
1696
67445f4e 1697 if (m->running_as == SYSTEMD_SYSTEM)
2b583ce6 1698 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
b925e726
LP		 1699 else
1700 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
d8d5ab98 1701
b925e726
LP		 1702 if (!path)
1703 return -ENOMEM;
a16e1123
LP		 1704
1705 saved_umask = umask(0077);
1706 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1707 umask(saved_umask);
1708
1709 if (fd < 0) {
1710 free(path);
1711 return -errno;
1712 }
1713
1714 unlink(path);
1715
1716 log_debug("Serializing state to %s", path);
1717 free(path);
1718
da19d5c1 1719 if (!(f = fdopen(fd, "w+")))
a16e1123
LP		 1720 return -errno;
1721
1722 *_f = f;
1723
1724 return 0;
1725}
1726
6b78f9b4 1727int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
a16e1123
LP		 1728 Iterator i;
1729 Unit *u;
1730 const char *t;
1731 int r;
1732
1733 assert(m);
1734 assert(f);
1735 assert(fds);
1736
a7556052 1737 m->n_reloading ++;
38c52d46 1738
01d67b43
LP		 1739 fprintf(f, "current-job-id=%i\n", m->current_job_id);
1740 fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
33c5fae9
LP		 1741 fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1742 fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
01d67b43 1743
915b3753
LP		 1744 dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1745 dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1746 dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
e9ddabc2 1747 dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
f38ed060 1748
26a1efdf 1749 if (!in_initrd()) {
915b3753 1750 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
f38ed060
HH		 1751 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1752 }
47a483a1 1753
f2382a94
LP		 1754 fputc('\n', f);
1755
a16e1123 1756 HASHMAP_FOREACH_KEY(u, t, m->units, i) {
ac155bb8 1757 if (u->id != t)
a16e1123
LP		 1758 continue;
1759
1760 if (!unit_can_serialize(u))
1761 continue;
1762
1763 /* Start marker */
ac155bb8 1764 fputs(u->id, f);
a16e1123
LP		 1765 fputc('\n', f);
1766
6b78f9b4 1767 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
a7556052 1768 m->n_reloading --;
a16e1123 1769 return r;
38c52d46 1770 }
a16e1123
LP		 1771 }
1772
a7556052
LP		 1773 assert(m->n_reloading > 0);
1774 m->n_reloading --;
38c52d46 1775
a16e1123
LP		 1776 if (ferror(f))
1777 return -EIO;
1778
b23de6af
LP		 1779 r = bus_fdset_add_all(m, fds);
1780 if (r < 0)
1781 return r;
1782
a16e1123
LP		 1783 return 0;
1784}
1785
1786int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1787 int r = 0;
1788
1789 assert(m);
1790 assert(f);
1791
1792 log_debug("Deserializing state...");
1793
a7556052 1794 m->n_reloading ++;
82c64bf5 1795
10f8e83c 1796 for (;;) {
20c03b7b 1797 char line[LINE_MAX], *l;
10f8e83c
LP		 1798
1799 if (!fgets(line, sizeof(line), f)) {
1800 if (feof(f))
1801 r = 0;
1802 else
1803 r = -errno;
1804
1805 goto finish;
1806 }
1807
1808 char_array_0(line);
1809 l = strstrip(line);
1810
1811 if (l[0] == 0)
1812 break;
1813
01d67b43
LP		 1814 if (startswith(l, "current-job-id=")) {
1815 uint32_t id;
1816
1817 if (safe_atou32(l+15, &id) < 0)
1818 log_debug("Failed to parse current job id value %s", l+15);
1819 else
1820 m->current_job_id = MAX(m->current_job_id, id);
33c5fae9
LP		 1821 } else if (startswith(l, "n-installed-jobs=")) {
1822 uint32_t n;
1823
1824 if (safe_atou32(l+17, &n) < 0)
1825 log_debug("Failed to parse installed jobs counter %s", l+17);
1826 else
1827 m->n_installed_jobs += n;
1828 } else if (startswith(l, "n-failed-jobs=")) {
1829 uint32_t n;
1830
1831 if (safe_atou32(l+14, &n) < 0)
1832 log_debug("Failed to parse failed jobs counter %s", l+14);
1833 else
1834 m->n_failed_jobs += n;
01d67b43
LP		 1835 } else if (startswith(l, "taint-usr=")) {
1836 int b;
1837
1838 if ((b = parse_boolean(l+10)) < 0)
1839 log_debug("Failed to parse taint /usr flag %s", l+10);
1840 else
1841 m->taint_usr = m->taint_usr || b;
915b3753
LP		 1842 } else if (startswith(l, "firmware-timestamp="))
1843 dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1844 else if (startswith(l, "loader-timestamp="))
1845 dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1846 else if (startswith(l, "kernel-timestamp="))
1847 dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1848 else if (startswith(l, "initrd-timestamp="))
e9ddabc2 1849 dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
915b3753
LP		 1850 else if (startswith(l, "userspace-timestamp="))
1851 dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
10717a1a 1852 else if (startswith(l, "finish-timestamp="))
799fd0fd 1853 dual_timestamp_deserialize(l+17, &m->finish_timestamp);
10717a1a 1854 else
10f8e83c
LP		 1855 log_debug("Unknown serialization item '%s'", l);
1856 }
1857
a16e1123
LP		 1858 for (;;) {
1859 Unit *u;
1860 char name[UNIT_NAME_MAX+2];
1861
1862 /* Start marker */
1863 if (!fgets(name, sizeof(name), f)) {
1864 if (feof(f))
10f8e83c
LP		 1865 r = 0;
1866 else
1867 r = -errno;
a16e1123 1868
82c64bf5 1869 goto finish;
a16e1123
LP		 1870 }
1871
1872 char_array_0(name);
1873
398ef8ba 1874 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
82c64bf5 1875 goto finish;
a16e1123
LP		 1876
1877 if ((r = unit_deserialize(u, f, fds)) < 0)
82c64bf5 1878 goto finish;
a16e1123
LP		 1879 }
1880
10f8e83c 1881finish:
82c64bf5
LP		 1882 if (ferror(f)) {
1883 r = -EIO;
1884 goto finish;
1885 }
a16e1123 1886
a7556052
LP		 1887 assert(m->n_reloading > 0);
1888 m->n_reloading --;
82c64bf5
LP		 1889
1890 return r;
a16e1123
LP		 1891}
1892
1893int manager_reload(Manager *m) {
1894 int r, q;
1895 FILE *f;
1896 FDSet *fds;
1897
1898 assert(m);
1899
07719a21
LP		 1900 r = manager_open_serialization(m, &f);
1901 if (r < 0)
a16e1123
LP		 1902 return r;
1903
a7556052 1904 m->n_reloading ++;
38c52d46 1905
07719a21
LP		 1906 fds = fdset_new();
1907 if (!fds) {
a7556052 1908 m->n_reloading --;
a16e1123
LP		 1909 r = -ENOMEM;
1910 goto finish;
1911 }
1912
6b78f9b4 1913 r = manager_serialize(m, f, fds, true);
07719a21 1914 if (r < 0) {
a7556052 1915 m->n_reloading --;
a16e1123 1916 goto finish;
38c52d46 1917 }
a16e1123
LP		 1918
1919 if (fseeko(f, 0, SEEK_SET) < 0) {
a7556052 1920 m->n_reloading --;
a16e1123
LP		 1921 r = -errno;
1922 goto finish;
1923 }
1924
1925 /* From here on there is no way back. */
1926 manager_clear_jobs_and_units(m);
5a1e9937 1927 manager_undo_generators(m);
84e3543e 1928 lookup_paths_free(&m->lookup_paths);
2ded0c04 1929
07719a21 1930 /* Find new unit paths */
5a1e9937
LP		 1931 manager_run_generators(m);
1932
07719a21
LP		 1933 q = lookup_paths_init(
1934 &m->lookup_paths, m->running_as, true,
1935 m->generator_unit_path,
1936 m->generator_unit_path_early,
1937 m->generator_unit_path_late);
1938 if (q < 0)
1939 r = q;
1940
5a1e9937
LP		 1941 manager_build_unit_path_cache(m);
1942
a16e1123 1943 /* First, enumerate what we can from all config files */
07719a21
LP		 1944 q = manager_enumerate(m);
1945 if (q < 0)
a16e1123
LP		 1946 r = q;
1947
1948 /* Second, deserialize our stored data */
07719a21
LP		 1949 q = manager_deserialize(m, f, fds);
1950 if (q < 0)
a16e1123
LP		 1951 r = q;
1952
1953 fclose(f);
1954 f = NULL;
1955
1956 /* Third, fire things up! */
07719a21
LP		 1957 q = manager_coldplug(m);
1958 if (q < 0)
a16e1123
LP		 1959 r = q;
1960
a7556052
LP		 1961 assert(m->n_reloading > 0);
1962 m->n_reloading--;
9f611ad8 1963
a16e1123
LP		 1964finish:
1965 if (f)
1966 fclose(f);
1967
1968 if (fds)
1969 fdset_free(fds);
1970
1971 return r;
1972}
1973
9e58ff9c
LP		 1974bool manager_is_booting_or_shutting_down(Manager *m) {
1975 Unit *u;
1976
1977 assert(m);
1978
1979 /* Is the initial job still around? */
bacbccb7 1980 if (manager_get_job(m, m->default_unit_job_id))
9e58ff9c
LP		 1981 return true;
1982
1983 /* Is there a job for the shutdown target? */
27d340c7
LP		 1984 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
1985 if (u)
ac155bb8 1986 return !!u->job;
9e58ff9c
LP		 1987
1988 return false;
1989}
1990
fdf20a31 1991void manager_reset_failed(Manager *m) {
5632e374
LP		 1992 Unit *u;
1993 Iterator i;
1994
1995 assert(m);
1996
1997 HASHMAP_FOREACH(u, m->units, i)
fdf20a31 1998 unit_reset_failed(u);
5632e374
LP		 1999}
2000
8f6df3fa
LP		 2001bool manager_unit_pending_inactive(Manager *m, const char *name) {
2002 Unit *u;
2003
2004 assert(m);
2005 assert(name);
2006
2007 /* Returns true if the unit is inactive or going down */
8f6df3fa
LP		 2008 if (!(u = manager_get_unit(m, name)))
2009 return true;
2010
18ffdfda 2011 return unit_pending_inactive(u);
8f6df3fa
LP		 2012}
2013
b0c918b9 2014void manager_check_finished(Manager *m) {
7ceba241 2015 char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
915b3753 2016 usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
b0c918b9
LP		 2017
2018 assert(m);
2019
f2b68789 2020 if (hashmap_size(m->jobs) > 0)
b0c918b9
LP		 2021 return;
2022
f2b68789
LP		 2023 /* Notify Type=idle units that we are done now */
2024 close_pipe(m->idle_pipe);
2025
af6da548
LP		 2026 /* Turn off confirm spawn now */
2027 m->confirm_spawn = false;
2028
f2b68789 2029 if (dual_timestamp_is_set(&m->finish_timestamp))
b0c918b9
LP		 2030 return;
2031
2032 dual_timestamp_get(&m->finish_timestamp);
2033
67445f4e 2034 if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
e03ae661 2035
915b3753
LP		 2036 /* Note that m->kernel_usec.monotonic is always at 0,
2037 * and m->firmware_usec.monotonic and
2038 * m->loader_usec.monotonic should be considered
2039 * negative values. */
2040
7ceba241
LP		 2041 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2042 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
915b3753 2043 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
7ceba241 2044 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
18fa6b27 2045
e9ddabc2 2046 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
18fa6b27 2047
915b3753
LP		 2048 kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2049 initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
18fa6b27 2050
81270860
LP		 2051 if (!log_on_console())
2052 log_struct(LOG_INFO,
1ca6783f 2053 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
81270860
LP		 2054 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2055 "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2056 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2057 "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2058 format_timespan(kernel, sizeof(kernel), kernel_usec),
2059 format_timespan(initrd, sizeof(initrd), initrd_usec),
2060 format_timespan(userspace, sizeof(userspace), userspace_usec),
2061 format_timespan(sum, sizeof(sum), total_usec),
2062 NULL);
18fa6b27 2063 } else {
915b3753 2064 kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
18fa6b27
LP		 2065 initrd_usec = 0;
2066
81270860
LP		 2067 if (!log_on_console())
2068 log_struct(LOG_INFO,
1ca6783f 2069 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
81270860
LP		 2070 "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2071 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2072 "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2073 format_timespan(kernel, sizeof(kernel), kernel_usec),
2074 format_timespan(userspace, sizeof(userspace), userspace_usec),
2075 format_timespan(sum, sizeof(sum), total_usec),
2076 NULL);
18fa6b27
LP		 2077 }
2078 } else {
915b3753
LP		 2079 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2080 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
877d54e9 2081
81270860
LP		 2082 if (!log_on_console())
2083 log_struct(LOG_INFO,
1ca6783f 2084 MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
81270860
LP		 2085 "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2086 "MESSAGE=Startup finished in %s.",
2087 format_timespan(sum, sizeof(sum), total_usec),
2088 NULL);
18fa6b27 2089 }
b0c918b9 2090
915b3753 2091 bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
530345e7
LP		 2092
2093 sd_notifyf(false,
2094 "READY=1\nSTATUS=Startup finished in %s.",
2095 format_timespan(sum, sizeof(sum), total_usec));
b0c918b9
LP		 2096}
2097
07719a21
LP		 2098static int create_generator_dir(Manager *m, char **generator, const char *name) {
2099 char *p;
2100 int r;
2101
2102 assert(m);
2103 assert(generator);
2104 assert(name);
2105
2106 if (*generator)
2107 return 0;
2108
67445f4e 2109 if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
07719a21
LP		 2110
2111 p = strappend("/run/systemd/", name);
0d0f0c50
SL		 2112 if (!p)
2113 return log_oom();
07719a21 2114
d2e54fae 2115 r = mkdir_p_label(p, 0755);
07719a21
LP		 2116 if (r < 0) {
2117 log_error("Failed to create generator directory: %s", strerror(-r));
2118 free(p);
2119 return r;
2120 }
2121 } else {
b7def684 2122 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
0d0f0c50
SL		 2123 if (!p)
2124 return log_oom();
07719a21
LP		 2125
2126 if (!mkdtemp(p)) {
2127 free(p);
2128 log_error("Failed to create generator directory: %m");
2129 return -errno;
2130 }
2131 }
2132
2133 *generator = p;
2134 return 0;
2135}
2136
2137static void trim_generator_dir(Manager *m, char **generator) {
2138 assert(m);
2139 assert(generator);
2140
2141 if (!*generator)
2142 return;
2143
2144 if (rmdir(*generator) >= 0) {
2145 free(*generator);
2146 *generator = NULL;
2147 }
2148
2149 return;
2150}
2151
5a1e9937
LP		 2152void manager_run_generators(Manager *m) {
2153 DIR *d = NULL;
5a1e9937 2154 const char *generator_path;
07719a21 2155 const char *argv[5];
07f8a4aa 2156 mode_t u;
07719a21 2157 int r;
5a1e9937
LP		 2158
2159 assert(m);
2160
67445f4e 2161 generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
07719a21
LP		 2162 d = opendir(generator_path);
2163 if (!d) {
5a1e9937
LP		 2164 if (errno == ENOENT)
2165 return;
2166
2167 log_error("Failed to enumerate generator directory: %m");
2168 return;
2169 }
2170
07719a21
LP		 2171 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2172 if (r < 0)
2173 goto finish;
f1d19aa4 2174
07719a21
LP		 2175 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2176 if (r < 0)
2177 goto finish;
5a1e9937 2178
07719a21
LP		 2179 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2180 if (r < 0)
2181 goto finish;
5a1e9937 2182
83cc030f
LP		 2183 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2184 argv[1] = m->generator_unit_path;
07719a21
LP		 2185 argv[2] = m->generator_unit_path_early;
2186 argv[3] = m->generator_unit_path_late;
2187 argv[4] = NULL;
5a1e9937 2188
07f8a4aa 2189 u = umask(0022);
83cc030f 2190 execute_directory(generator_path, d, (char**) argv);
07f8a4aa 2191 umask(u);
5a1e9937 2192
07719a21
LP		 2193 trim_generator_dir(m, &m->generator_unit_path);
2194 trim_generator_dir(m, &m->generator_unit_path_early);
2195 trim_generator_dir(m, &m->generator_unit_path_late);
5a1e9937
LP		 2196
2197finish:
2198 if (d)
2199 closedir(d);
5a1e9937
LP		 2200}
2201
07719a21 2202static void remove_generator_dir(Manager *m, char **generator) {
5a1e9937 2203 assert(m);
07719a21 2204 assert(generator);
5a1e9937 2205
07719a21 2206 if (!*generator)
5a1e9937
LP		 2207 return;
2208
07719a21
LP		 2209 strv_remove(m->lookup_paths.unit_path, *generator);
2210 rm_rf(*generator, false, true, false);
5a1e9937 2211
07719a21
LP		 2212 free(*generator);
2213 *generator = NULL;
2214}
2215
2216void manager_undo_generators(Manager *m) {
2217 assert(m);
2218
2219 remove_generator_dir(m, &m->generator_unit_path);
2220 remove_generator_dir(m, &m->generator_unit_path_early);
2221 remove_generator_dir(m, &m->generator_unit_path_late);
5a1e9937
LP		 2222}
2223
06d4c99a
LP		 2224int manager_set_default_controllers(Manager *m, char **controllers) {
2225 char **l;
2226
2227 assert(m);
2228
9156e799
LP		 2229 l = strv_copy(controllers);
2230 if (!l)
06d4c99a
LP		 2231 return -ENOMEM;
2232
2233 strv_free(m->default_controllers);
2234 m->default_controllers = l;
2235
b59e2465 2236 cg_shorten_controllers(m->default_controllers);
9156e799 2237
06d4c99a
LP		 2238 return 0;
2239}
2240
c93ff2e9
FC		 2241int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2242 int i;
2243
2244 assert(m);
2245
2246 for (i = 0; i < RLIMIT_NLIMITS; i++) {
07719a21
LP		 2247 if (!default_rlimit[i])
2248 continue;
c93ff2e9 2249
07719a21
LP		 2250 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2251 if (!m->rlimit[i])
2252 return -ENOMEM;
c93ff2e9
FC		 2253 }
2254
2255 return 0;
2256}
2257
4cfa2c99 2258void manager_recheck_journal(Manager *m) {
f1dd0c3f
LP		 2259 Unit *u;
2260
2261 assert(m);
2262
67445f4e 2263 if (m->running_as != SYSTEMD_SYSTEM)
f1dd0c3f
LP		 2264 return;
2265
731a676c
LP		 2266 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2267 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
4cfa2c99 2268 log_close_journal();
731a676c 2269 return;
f1dd0c3f
LP		 2270 }
2271
731a676c
LP		 2272 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2273 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
4cfa2c99 2274 log_close_journal();
731a676c
LP		 2275 return;
2276 }
f1dd0c3f 2277
731a676c
LP		 2278 /* Hmm, OK, so the socket is fully up and the service is up
2279 * too, then let's make use of the thing. */
f1dd0c3f
LP		 2280 log_open();
2281}
2282
27d340c7
LP		 2283void manager_set_show_status(Manager *m, bool b) {
2284 assert(m);
2285
67445f4e 2286 if (m->running_as != SYSTEMD_SYSTEM)
27d340c7
LP		 2287 return;
2288
2289 m->show_status = b;
2290
2291 if (b)
2292 touch("/run/systemd/show-status");
2293 else
2294 unlink("/run/systemd/show-status");
2295}
2296
2297bool manager_get_show_status(Manager *m) {
2298 assert(m);
2299
67445f4e 2300 if (m->running_as != SYSTEMD_SYSTEM)
27d340c7
LP		 2301 return false;
2302
2303 if (m->show_status)
2304 return true;
2305
2306 /* If Plymouth is running make sure we show the status, so
2307 * that there's something nice to see when people press Esc */
2308
2309 return plymouth_running();
2310}
68b29a9f
LP		 2311
2312void watch_init(Watch *w) {
2313 assert(w);
2314
2315 w->type = WATCH_INVALID;
2316 w->fd = -1;
2317}
Unnamed repository; edit this file 'description' to name the repository.