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