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