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