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