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