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