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