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