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