]> 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
util-lib: split string parsing related calls from util.[ch] into parse-util.[ch]
[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 "io-util.h"
59 #include "locale-setup.h"
60 #include "log.h"
61 #include "macro.h"
62 #include "manager.h"
63 #include "missing.h"
64 #include "mkdir.h"
65 #include "parse-util.h"
66 #include "path-lookup.h"
67 #include "path-util.h"
68 #include "process-util.h"
69 #include "ratelimit.h"
70 #include "rm-rf.h"
71 #include "signal-util.h"
72 #include "special.h"
73 #include "string-util.h"
74 #include "strv.h"
75 #include "terminal-util.h"
76 #include "time-util.h"
77 #include "transaction.h"
78 #include "unit-name.h"
79 #include "util.h"
80 #include "virt.h"
81 #include "watchdog.h"
82
83 /* Initial delay and the interval for printing status messages about running jobs */
84 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
85 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
86 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
87
88 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
89 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
90 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
91 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
92 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
93 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
94 static int manager_run_generators(Manager *m);
95 static void manager_undo_generators(Manager *m);
96
97 static void manager_watch_jobs_in_progress(Manager *m) {
98 usec_t next;
99 int r;
100
101 assert(m);
102
103 if (m->jobs_in_progress_event_source)
104 return;
105
106 next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
107 r = sd_event_add_time(
108 m->event,
109 &m->jobs_in_progress_event_source,
110 CLOCK_MONOTONIC,
111 next, 0,
112 manager_dispatch_jobs_in_progress, m);
113 if (r < 0)
114 return;
115
116 (void) sd_event_source_set_description(m->jobs_in_progress_event_source, "manager-jobs-in-progress");
117 }
118
119 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED)-1) + sizeof(ANSI_HIGHLIGHT_RED)-1 + 2*(sizeof(ANSI_NORMAL)-1))
120
121 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
122 char *p = buffer;
123
124 assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
125 assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
126
127 if (pos > 1) {
128 if (pos > 2)
129 p = mempset(p, ' ', pos-2);
130 p = stpcpy(p, ANSI_RED);
131 *p++ = '*';
132 }
133
134 if (pos > 0 && pos <= width) {
135 p = stpcpy(p, ANSI_HIGHLIGHT_RED);
136 *p++ = '*';
137 }
138
139 p = stpcpy(p, ANSI_NORMAL);
140
141 if (pos < width) {
142 p = stpcpy(p, ANSI_RED);
143 *p++ = '*';
144 if (pos < width-1)
145 p = mempset(p, ' ', width-1-pos);
146 strcpy(p, ANSI_NORMAL);
147 }
148 }
149
150 void manager_flip_auto_status(Manager *m, bool enable) {
151 assert(m);
152
153 if (enable) {
154 if (m->show_status == SHOW_STATUS_AUTO)
155 manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
156 } else {
157 if (m->show_status == SHOW_STATUS_TEMPORARY)
158 manager_set_show_status(m, SHOW_STATUS_AUTO);
159 }
160 }
161
162 static void manager_print_jobs_in_progress(Manager *m) {
163 _cleanup_free_ char *job_of_n = NULL;
164 Iterator i;
165 Job *j;
166 unsigned counter = 0, print_nr;
167 char cylon[6 + CYLON_BUFFER_EXTRA + 1];
168 unsigned cylon_pos;
169 char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
170 uint64_t x;
171
172 assert(m);
173 assert(m->n_running_jobs > 0);
174
175 manager_flip_auto_status(m, true);
176
177 print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
178
179 HASHMAP_FOREACH(j, m->jobs, i)
180 if (j->state == JOB_RUNNING && counter++ == print_nr)
181 break;
182
183 /* m->n_running_jobs must be consistent with the contents of m->jobs,
184 * so the above loop must have succeeded in finding j. */
185 assert(counter == print_nr + 1);
186 assert(j);
187
188 cylon_pos = m->jobs_in_progress_iteration % 14;
189 if (cylon_pos >= 8)
190 cylon_pos = 14 - cylon_pos;
191 draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
192
193 m->jobs_in_progress_iteration++;
194
195 if (m->n_running_jobs > 1) {
196 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
197 job_of_n = NULL;
198 }
199
200 format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
201 if (job_get_timeout(j, &x) > 0)
202 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
203
204 manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
205 "%sA %s job is running for %s (%s / %s)",
206 strempty(job_of_n),
207 job_type_to_string(j->type),
208 unit_description(j->unit),
209 time, limit);
210 }
211
212 static int have_ask_password(void) {
213 _cleanup_closedir_ DIR *dir;
214
215 dir = opendir("/run/systemd/ask-password");
216 if (!dir) {
217 if (errno == ENOENT)
218 return false;
219 else
220 return -errno;
221 }
222
223 for (;;) {
224 struct dirent *de;
225
226 errno = 0;
227 de = readdir(dir);
228 if (!de && errno != 0)
229 return -errno;
230 if (!de)
231 return false;
232
233 if (startswith(de->d_name, "ask."))
234 return true;
235 }
236 }
237
238 static int manager_dispatch_ask_password_fd(sd_event_source *source,
239 int fd, uint32_t revents, void *userdata) {
240 Manager *m = userdata;
241
242 assert(m);
243
244 flush_fd(fd);
245
246 m->have_ask_password = have_ask_password();
247 if (m->have_ask_password < 0)
248 /* Log error but continue. Negative have_ask_password
249 * is treated as unknown status. */
250 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
251
252 return 0;
253 }
254
255 static void manager_close_ask_password(Manager *m) {
256 assert(m);
257
258 m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
259 m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
260 m->have_ask_password = -EINVAL;
261 }
262
263 static int manager_check_ask_password(Manager *m) {
264 int r;
265
266 assert(m);
267
268 if (!m->ask_password_event_source) {
269 assert(m->ask_password_inotify_fd < 0);
270
271 mkdir_p_label("/run/systemd/ask-password", 0755);
272
273 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
274 if (m->ask_password_inotify_fd < 0)
275 return log_error_errno(errno, "inotify_init1() failed: %m");
276
277 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
278 log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
279 manager_close_ask_password(m);
280 return -errno;
281 }
282
283 r = sd_event_add_io(m->event, &m->ask_password_event_source,
284 m->ask_password_inotify_fd, EPOLLIN,
285 manager_dispatch_ask_password_fd, m);
286 if (r < 0) {
287 log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
288 manager_close_ask_password(m);
289 return -errno;
290 }
291
292 (void) sd_event_source_set_description(m->ask_password_event_source, "manager-ask-password");
293
294 /* Queries might have been added meanwhile... */
295 manager_dispatch_ask_password_fd(m->ask_password_event_source,
296 m->ask_password_inotify_fd, EPOLLIN, m);
297 }
298
299 return m->have_ask_password;
300 }
301
302 static int manager_watch_idle_pipe(Manager *m) {
303 int r;
304
305 assert(m);
306
307 if (m->idle_pipe_event_source)
308 return 0;
309
310 if (m->idle_pipe[2] < 0)
311 return 0;
312
313 r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
314 if (r < 0)
315 return log_error_errno(r, "Failed to watch idle pipe: %m");
316
317 (void) sd_event_source_set_description(m->idle_pipe_event_source, "manager-idle-pipe");
318
319 return 0;
320 }
321
322 static void manager_close_idle_pipe(Manager *m) {
323 assert(m);
324
325 m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
326
327 safe_close_pair(m->idle_pipe);
328 safe_close_pair(m->idle_pipe + 2);
329 }
330
331 static int manager_setup_time_change(Manager *m) {
332 int r;
333
334 /* We only care for the cancellation event, hence we set the
335 * timeout to the latest possible value. */
336 struct itimerspec its = {
337 .it_value.tv_sec = TIME_T_MAX,
338 };
339
340 assert(m);
341 assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
342
343 if (m->test_run)
344 return 0;
345
346 /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
347 * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
348
349 m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
350 if (m->time_change_fd < 0)
351 return log_error_errno(errno, "Failed to create timerfd: %m");
352
353 if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
354 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
355 m->time_change_fd = safe_close(m->time_change_fd);
356 return 0;
357 }
358
359 r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
360 if (r < 0)
361 return log_error_errno(r, "Failed to create time change event source: %m");
362
363 (void) sd_event_source_set_description(m->time_change_event_source, "manager-time-change");
364
365 log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
366
367 return 0;
368 }
369
370 static int enable_special_signals(Manager *m) {
371 _cleanup_close_ int fd = -1;
372
373 assert(m);
374
375 /* Enable that we get SIGINT on control-alt-del. In containers
376 * this will fail with EPERM (older) or EINVAL (newer), so
377 * ignore that. */
378 if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
379 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
380
381 fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
382 if (fd < 0) {
383 /* Support systems without virtual console */
384 if (fd != -ENOENT)
385 log_warning_errno(errno, "Failed to open /dev/tty0: %m");
386 } else {
387 /* Enable that we get SIGWINCH on kbrequest */
388 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
389 log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
390 }
391
392 return 0;
393 }
394
395 static int manager_setup_signals(Manager *m) {
396 struct sigaction sa = {
397 .sa_handler = SIG_DFL,
398 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
399 };
400 sigset_t mask;
401 int r;
402
403 assert(m);
404
405 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
406
407 /* We make liberal use of realtime signals here. On
408 * Linux/glibc we have 30 of them (with the exception of Linux
409 * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
410 * (aka SIGRTMAX). */
411
412 assert_se(sigemptyset(&mask) == 0);
413 sigset_add_many(&mask,
414 SIGCHLD, /* Child died */
415 SIGTERM, /* Reexecute daemon */
416 SIGHUP, /* Reload configuration */
417 SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
418 SIGUSR2, /* systemd: dump status */
419 SIGINT, /* Kernel sends us this on control-alt-del */
420 SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
421 SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
422
423 SIGRTMIN+0, /* systemd: start default.target */
424 SIGRTMIN+1, /* systemd: isolate rescue.target */
425 SIGRTMIN+2, /* systemd: isolate emergency.target */
426 SIGRTMIN+3, /* systemd: start halt.target */
427 SIGRTMIN+4, /* systemd: start poweroff.target */
428 SIGRTMIN+5, /* systemd: start reboot.target */
429 SIGRTMIN+6, /* systemd: start kexec.target */
430
431 /* ... space for more special targets ... */
432
433 SIGRTMIN+13, /* systemd: Immediate halt */
434 SIGRTMIN+14, /* systemd: Immediate poweroff */
435 SIGRTMIN+15, /* systemd: Immediate reboot */
436 SIGRTMIN+16, /* systemd: Immediate kexec */
437
438 /* ... space for more immediate system state changes ... */
439
440 SIGRTMIN+20, /* systemd: enable status messages */
441 SIGRTMIN+21, /* systemd: disable status messages */
442 SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
443 SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
444 SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
445
446 /* .. one free signal here ... */
447
448 #if !defined(__hppa64__) && !defined(__hppa__)
449 /* Apparently Linux on hppa has fewer RT
450 * signals (SIGRTMAX is SIGRTMIN+25 there),
451 * hence let's not try to make use of them
452 * here. Since these commands are accessible
453 * by different means and only really a safety
454 * net, the missing functionality on hppa
455 * shouldn't matter. */
456
457 SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
458 SIGRTMIN+27, /* systemd: set log target to console */
459 SIGRTMIN+28, /* systemd: set log target to kmsg */
460 SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
461
462 /* ... one free signal here SIGRTMIN+30 ... */
463 #endif
464 -1);
465 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
466
467 m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
468 if (m->signal_fd < 0)
469 return -errno;
470
471 r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
472 if (r < 0)
473 return r;
474
475 (void) sd_event_source_set_description(m->signal_event_source, "manager-signal");
476
477 /* Process signals a bit earlier than the rest of things, but
478 * later than notify_fd processing, so that the notify
479 * processing can still figure out to which process/service a
480 * message belongs, before we reap the process. */
481 r = sd_event_source_set_priority(m->signal_event_source, -5);
482 if (r < 0)
483 return r;
484
485 if (m->running_as == MANAGER_SYSTEM)
486 return enable_special_signals(m);
487
488 return 0;
489 }
490
491 static void manager_clean_environment(Manager *m) {
492 assert(m);
493
494 /* Let's remove some environment variables that we
495 * need ourselves to communicate with our clients */
496 strv_env_unset_many(
497 m->environment,
498 "NOTIFY_SOCKET",
499 "MAINPID",
500 "MANAGERPID",
501 "LISTEN_PID",
502 "LISTEN_FDS",
503 "LISTEN_FDNAMES",
504 "WATCHDOG_PID",
505 "WATCHDOG_USEC",
506 NULL);
507 }
508
509 static int manager_default_environment(Manager *m) {
510 assert(m);
511
512 if (m->running_as == MANAGER_SYSTEM) {
513 /* The system manager always starts with a clean
514 * environment for its children. It does not import
515 * the kernel or the parents exported variables.
516 *
517 * The initial passed environ is untouched to keep
518 * /proc/self/environ valid; it is used for tagging
519 * the init process inside containers. */
520 m->environment = strv_new("PATH=" DEFAULT_PATH,
521 NULL);
522
523 /* Import locale variables LC_*= from configuration */
524 locale_setup(&m->environment);
525 } else {
526 /* The user manager passes its own environment
527 * along to its children. */
528 m->environment = strv_copy(environ);
529 }
530
531 if (!m->environment)
532 return -ENOMEM;
533
534 manager_clean_environment(m);
535 strv_sort(m->environment);
536
537 return 0;
538 }
539
540
541 int manager_new(ManagerRunningAs running_as, bool test_run, Manager **_m) {
542
543 static const char * const unit_log_fields[_MANAGER_RUNNING_AS_MAX] = {
544 [MANAGER_SYSTEM] = "UNIT=",
545 [MANAGER_USER] = "USER_UNIT=",
546 };
547
548 static const char * const unit_log_format_strings[_MANAGER_RUNNING_AS_MAX] = {
549 [MANAGER_SYSTEM] = "UNIT=%s",
550 [MANAGER_USER] = "USER_UNIT=%s",
551 };
552
553 Manager *m;
554 int r;
555
556 assert(_m);
557 assert(running_as >= 0);
558 assert(running_as < _MANAGER_RUNNING_AS_MAX);
559
560 m = new0(Manager, 1);
561 if (!m)
562 return -ENOMEM;
563
564 #ifdef ENABLE_EFI
565 if (running_as == MANAGER_SYSTEM && detect_container() <= 0)
566 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
567 #endif
568
569 m->running_as = running_as;
570 m->exit_code = _MANAGER_EXIT_CODE_INVALID;
571 m->default_timer_accuracy_usec = USEC_PER_MINUTE;
572
573 /* Prepare log fields we can use for structured logging */
574 m->unit_log_field = unit_log_fields[running_as];
575 m->unit_log_format_string = unit_log_format_strings[running_as];
576
577 m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
578
579 m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd =
580 m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = m->cgroup_inotify_fd = -1;
581
582 m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
583
584 m->ask_password_inotify_fd = -1;
585 m->have_ask_password = -EINVAL; /* we don't know */
586 m->first_boot = -1;
587
588 m->cgroup_netclass_registry_last = CGROUP_NETCLASS_FIXED_MAX;
589
590 m->test_run = test_run;
591
592 /* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
593 RATELIMIT_INIT(m->ctrl_alt_del_ratelimit, 2 * USEC_PER_SEC, 7);
594
595 r = manager_default_environment(m);
596 if (r < 0)
597 goto fail;
598
599 r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
600 if (r < 0)
601 goto fail;
602
603 r = hashmap_ensure_allocated(&m->jobs, NULL);
604 if (r < 0)
605 goto fail;
606
607 r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
608 if (r < 0)
609 goto fail;
610
611 r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
612 if (r < 0)
613 goto fail;
614
615 r = sd_event_default(&m->event);
616 if (r < 0)
617 goto fail;
618
619 r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
620 if (r < 0)
621 goto fail;
622
623 r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
624 if (r < 0)
625 goto fail;
626
627 r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
628 if (r < 0)
629 goto fail;
630
631 (void) sd_event_source_set_description(m->run_queue_event_source, "manager-run-queue");
632
633 r = manager_setup_signals(m);
634 if (r < 0)
635 goto fail;
636
637 r = manager_setup_cgroup(m);
638 if (r < 0)
639 goto fail;
640
641 r = manager_setup_time_change(m);
642 if (r < 0)
643 goto fail;
644
645 m->udev = udev_new();
646 if (!m->udev) {
647 r = -ENOMEM;
648 goto fail;
649 }
650
651 /* Note that we set up neither kdbus, nor the notify fd
652 * here. We do that after deserialization, since they might
653 * have gotten serialized across the reexec. */
654
655 m->taint_usr = dir_is_empty("/usr") > 0;
656
657 *_m = m;
658 return 0;
659
660 fail:
661 manager_free(m);
662 return r;
663 }
664
665 static int manager_setup_notify(Manager *m) {
666 int r;
667
668 if (m->test_run)
669 return 0;
670
671 if (m->notify_fd < 0) {
672 _cleanup_close_ int fd = -1;
673 union sockaddr_union sa = {
674 .sa.sa_family = AF_UNIX,
675 };
676 static const int one = 1;
677
678 /* First free all secondary fields */
679 m->notify_socket = mfree(m->notify_socket);
680 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
681
682 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
683 if (fd < 0)
684 return log_error_errno(errno, "Failed to allocate notification socket: %m");
685
686 if (m->running_as == MANAGER_SYSTEM)
687 m->notify_socket = strdup("/run/systemd/notify");
688 else {
689 const char *e;
690
691 e = getenv("XDG_RUNTIME_DIR");
692 if (!e) {
693 log_error_errno(errno, "XDG_RUNTIME_DIR is not set: %m");
694 return -EINVAL;
695 }
696
697 m->notify_socket = strappend(e, "/systemd/notify");
698 }
699 if (!m->notify_socket)
700 return log_oom();
701
702 (void) mkdir_parents_label(m->notify_socket, 0755);
703 (void) unlink(m->notify_socket);
704
705 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
706 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path));
707 if (r < 0)
708 return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
709
710 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
711 if (r < 0)
712 return log_error_errno(errno, "SO_PASSCRED failed: %m");
713
714 m->notify_fd = fd;
715 fd = -1;
716
717 log_debug("Using notification socket %s", m->notify_socket);
718 }
719
720 if (!m->notify_event_source) {
721 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
722 if (r < 0)
723 return log_error_errno(r, "Failed to allocate notify event source: %m");
724
725 /* Process signals a bit earlier than SIGCHLD, so that we can
726 * still identify to which service an exit message belongs */
727 r = sd_event_source_set_priority(m->notify_event_source, -7);
728 if (r < 0)
729 return log_error_errno(r, "Failed to set priority of notify event source: %m");
730
731 (void) sd_event_source_set_description(m->notify_event_source, "manager-notify");
732 }
733
734 return 0;
735 }
736
737 static int manager_setup_kdbus(Manager *m) {
738 _cleanup_free_ char *p = NULL;
739
740 assert(m);
741
742 if (m->test_run || m->kdbus_fd >= 0)
743 return 0;
744 if (!is_kdbus_available())
745 return -ESOCKTNOSUPPORT;
746
747 m->kdbus_fd = bus_kernel_create_bus(
748 m->running_as == MANAGER_SYSTEM ? "system" : "user",
749 m->running_as == MANAGER_SYSTEM, &p);
750
751 if (m->kdbus_fd < 0)
752 return log_debug_errno(m->kdbus_fd, "Failed to set up kdbus: %m");
753
754 log_debug("Successfully set up kdbus on %s", p);
755
756 return 0;
757 }
758
759 static int manager_connect_bus(Manager *m, bool reexecuting) {
760 bool try_bus_connect;
761
762 assert(m);
763
764 if (m->test_run)
765 return 0;
766
767 try_bus_connect =
768 m->kdbus_fd >= 0 ||
769 reexecuting ||
770 (m->running_as == MANAGER_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
771
772 /* Try to connect to the buses, if possible. */
773 return bus_init(m, try_bus_connect);
774 }
775
776 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
777 Unit *u;
778 unsigned n = 0;
779
780 assert(m);
781
782 while ((u = m->cleanup_queue)) {
783 assert(u->in_cleanup_queue);
784
785 unit_free(u);
786 n++;
787 }
788
789 return n;
790 }
791
792 enum {
793 GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
794 GC_OFFSET_UNSURE, /* No clue */
795 GC_OFFSET_GOOD, /* We still need this unit */
796 GC_OFFSET_BAD, /* We don't need this unit anymore */
797 _GC_OFFSET_MAX
798 };
799
800 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
801 Iterator i;
802 Unit *other;
803 bool is_bad;
804
805 assert(u);
806
807 if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
808 u->gc_marker == gc_marker + GC_OFFSET_BAD ||
809 u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
810 return;
811
812 if (u->in_cleanup_queue)
813 goto bad;
814
815 if (unit_check_gc(u))
816 goto good;
817
818 u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
819
820 is_bad = true;
821
822 SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
823 unit_gc_sweep(other, gc_marker);
824
825 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
826 goto good;
827
828 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
829 is_bad = false;
830 }
831
832 if (is_bad)
833 goto bad;
834
835 /* We were unable to find anything out about this entry, so
836 * let's investigate it later */
837 u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
838 unit_add_to_gc_queue(u);
839 return;
840
841 bad:
842 /* We definitely know that this one is not useful anymore, so
843 * let's mark it for deletion */
844 u->gc_marker = gc_marker + GC_OFFSET_BAD;
845 unit_add_to_cleanup_queue(u);
846 return;
847
848 good:
849 u->gc_marker = gc_marker + GC_OFFSET_GOOD;
850 }
851
852 static unsigned manager_dispatch_gc_queue(Manager *m) {
853 Unit *u;
854 unsigned n = 0;
855 unsigned gc_marker;
856
857 assert(m);
858
859 /* log_debug("Running GC..."); */
860
861 m->gc_marker += _GC_OFFSET_MAX;
862 if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
863 m->gc_marker = 1;
864
865 gc_marker = m->gc_marker;
866
867 while ((u = m->gc_queue)) {
868 assert(u->in_gc_queue);
869
870 unit_gc_sweep(u, gc_marker);
871
872 LIST_REMOVE(gc_queue, m->gc_queue, u);
873 u->in_gc_queue = false;
874
875 n++;
876
877 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
878 u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
879 if (u->id)
880 log_unit_debug(u, "Collecting.");
881 u->gc_marker = gc_marker + GC_OFFSET_BAD;
882 unit_add_to_cleanup_queue(u);
883 }
884 }
885
886 m->n_in_gc_queue = 0;
887
888 return n;
889 }
890
891 static void manager_clear_jobs_and_units(Manager *m) {
892 Unit *u;
893
894 assert(m);
895
896 while ((u = hashmap_first(m->units)))
897 unit_free(u);
898
899 manager_dispatch_cleanup_queue(m);
900
901 assert(!m->load_queue);
902 assert(!m->run_queue);
903 assert(!m->dbus_unit_queue);
904 assert(!m->dbus_job_queue);
905 assert(!m->cleanup_queue);
906 assert(!m->gc_queue);
907
908 assert(hashmap_isempty(m->jobs));
909 assert(hashmap_isempty(m->units));
910
911 m->n_on_console = 0;
912 m->n_running_jobs = 0;
913 }
914
915 Manager* manager_free(Manager *m) {
916 UnitType c;
917 int i;
918
919 if (!m)
920 return NULL;
921
922 manager_clear_jobs_and_units(m);
923
924 for (c = 0; c < _UNIT_TYPE_MAX; c++)
925 if (unit_vtable[c]->shutdown)
926 unit_vtable[c]->shutdown(m);
927
928 /* If we reexecute ourselves, we keep the root cgroup
929 * around */
930 manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
931
932 manager_undo_generators(m);
933
934 bus_done(m);
935
936 hashmap_free(m->units);
937 hashmap_free(m->jobs);
938 hashmap_free(m->watch_pids1);
939 hashmap_free(m->watch_pids2);
940 hashmap_free(m->watch_bus);
941
942 set_free(m->startup_units);
943 set_free(m->failed_units);
944
945 sd_event_source_unref(m->signal_event_source);
946 sd_event_source_unref(m->notify_event_source);
947 sd_event_source_unref(m->time_change_event_source);
948 sd_event_source_unref(m->jobs_in_progress_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 hashmap_free(m->cgroup_netclass_registry);
972
973 free(m->switch_root);
974 free(m->switch_root_init);
975
976 for (i = 0; i < _RLIMIT_MAX; i++)
977 free(m->rlimit[i]);
978
979 assert(hashmap_isempty(m->units_requiring_mounts_for));
980 hashmap_free(m->units_requiring_mounts_for);
981
982 free(m);
983 return NULL;
984 }
985
986 int manager_enumerate(Manager *m) {
987 int r = 0;
988 UnitType c;
989
990 assert(m);
991
992 /* Let's ask every type to load all units from disk/kernel
993 * that it might know */
994 for (c = 0; c < _UNIT_TYPE_MAX; c++) {
995 int q;
996
997 if (!unit_type_supported(c)) {
998 log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
999 continue;
1000 }
1001
1002 if (!unit_vtable[c]->enumerate)
1003 continue;
1004
1005 q = unit_vtable[c]->enumerate(m);
1006 if (q < 0)
1007 r = q;
1008 }
1009
1010 manager_dispatch_load_queue(m);
1011 return r;
1012 }
1013
1014 static void manager_coldplug(Manager *m) {
1015 Iterator i;
1016 Unit *u;
1017 char *k;
1018 int r;
1019
1020 assert(m);
1021
1022 /* Then, let's set up their initial state. */
1023 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1024
1025 /* ignore aliases */
1026 if (u->id != k)
1027 continue;
1028
1029 r = unit_coldplug(u);
1030 if (r < 0)
1031 log_warning_errno(r, "We couldn't coldplug %s, proceeding anyway: %m", u->id);
1032 }
1033 }
1034
1035 static void manager_build_unit_path_cache(Manager *m) {
1036 char **i;
1037 _cleanup_closedir_ DIR *d = NULL;
1038 int r;
1039
1040 assert(m);
1041
1042 set_free_free(m->unit_path_cache);
1043
1044 m->unit_path_cache = set_new(&string_hash_ops);
1045 if (!m->unit_path_cache) {
1046 log_error("Failed to allocate unit path cache.");
1047 return;
1048 }
1049
1050 /* This simply builds a list of files we know exist, so that
1051 * we don't always have to go to disk */
1052
1053 STRV_FOREACH(i, m->lookup_paths.unit_path) {
1054 struct dirent *de;
1055
1056 d = opendir(*i);
1057 if (!d) {
1058 if (errno != ENOENT)
1059 log_error_errno(errno, "Failed to open directory %s: %m", *i);
1060 continue;
1061 }
1062
1063 while ((de = readdir(d))) {
1064 char *p;
1065
1066 if (hidden_file(de->d_name))
1067 continue;
1068
1069 p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
1070 if (!p) {
1071 r = -ENOMEM;
1072 goto fail;
1073 }
1074
1075 r = set_consume(m->unit_path_cache, p);
1076 if (r < 0)
1077 goto fail;
1078 }
1079
1080 d = safe_closedir(d);
1081 }
1082
1083 return;
1084
1085 fail:
1086 log_error_errno(r, "Failed to build unit path cache: %m");
1087
1088 set_free_free(m->unit_path_cache);
1089 m->unit_path_cache = NULL;
1090 }
1091
1092
1093 static int manager_distribute_fds(Manager *m, FDSet *fds) {
1094 Unit *u;
1095 Iterator i;
1096 int r;
1097
1098 assert(m);
1099
1100 HASHMAP_FOREACH(u, m->units, i) {
1101
1102 if (fdset_size(fds) <= 0)
1103 break;
1104
1105 if (UNIT_VTABLE(u)->distribute_fds) {
1106 r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1107 if (r < 0)
1108 return r;
1109 }
1110 }
1111
1112 return 0;
1113 }
1114
1115 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1116 int r, q;
1117
1118 assert(m);
1119
1120 dual_timestamp_get(&m->generators_start_timestamp);
1121 r = manager_run_generators(m);
1122 dual_timestamp_get(&m->generators_finish_timestamp);
1123 if (r < 0)
1124 return r;
1125
1126 r = lookup_paths_init(
1127 &m->lookup_paths, m->running_as, true,
1128 NULL,
1129 m->generator_unit_path,
1130 m->generator_unit_path_early,
1131 m->generator_unit_path_late);
1132 if (r < 0)
1133 return r;
1134
1135 manager_build_unit_path_cache(m);
1136
1137 /* If we will deserialize make sure that during enumeration
1138 * this is already known, so we increase the counter here
1139 * already */
1140 if (serialization)
1141 m->n_reloading ++;
1142
1143 /* First, enumerate what we can from all config files */
1144 dual_timestamp_get(&m->units_load_start_timestamp);
1145 r = manager_enumerate(m);
1146 dual_timestamp_get(&m->units_load_finish_timestamp);
1147
1148 /* Second, deserialize if there is something to deserialize */
1149 if (serialization)
1150 r = manager_deserialize(m, serialization, fds);
1151
1152 /* Any fds left? Find some unit which wants them. This is
1153 * useful to allow container managers to pass some file
1154 * descriptors to us pre-initialized. This enables
1155 * socket-based activation of entire containers. */
1156 if (fdset_size(fds) > 0) {
1157 q = manager_distribute_fds(m, fds);
1158 if (q < 0 && r == 0)
1159 r = q;
1160 }
1161
1162 /* We might have deserialized the notify fd, but if we didn't
1163 * then let's create the bus now */
1164 q = manager_setup_notify(m);
1165 if (q < 0 && r == 0)
1166 r = q;
1167
1168 /* We might have deserialized the kdbus control fd, but if we
1169 * didn't, then let's create the bus now. */
1170 manager_setup_kdbus(m);
1171 manager_connect_bus(m, !!serialization);
1172 bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1173
1174 /* Third, fire things up! */
1175 manager_coldplug(m);
1176
1177 if (serialization) {
1178 assert(m->n_reloading > 0);
1179 m->n_reloading --;
1180
1181 /* Let's wait for the UnitNew/JobNew messages being
1182 * sent, before we notify that the reload is
1183 * finished */
1184 m->send_reloading_done = true;
1185 }
1186
1187 return r;
1188 }
1189
1190 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1191 int r;
1192 Transaction *tr;
1193
1194 assert(m);
1195 assert(type < _JOB_TYPE_MAX);
1196 assert(unit);
1197 assert(mode < _JOB_MODE_MAX);
1198
1199 if (mode == JOB_ISOLATE && type != JOB_START)
1200 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1201
1202 if (mode == JOB_ISOLATE && !unit->allow_isolate)
1203 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1204
1205 log_unit_debug(unit, "Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1206
1207 type = job_type_collapse(type, unit);
1208
1209 tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1210 if (!tr)
1211 return -ENOMEM;
1212
1213 r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1214 mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1215 mode == JOB_IGNORE_DEPENDENCIES, e);
1216 if (r < 0)
1217 goto tr_abort;
1218
1219 if (mode == JOB_ISOLATE) {
1220 r = transaction_add_isolate_jobs(tr, m);
1221 if (r < 0)
1222 goto tr_abort;
1223 }
1224
1225 r = transaction_activate(tr, m, mode, e);
1226 if (r < 0)
1227 goto tr_abort;
1228
1229 log_unit_debug(unit,
1230 "Enqueued job %s/%s as %u", unit->id,
1231 job_type_to_string(type), (unsigned) tr->anchor_job->id);
1232
1233 if (_ret)
1234 *_ret = tr->anchor_job;
1235
1236 transaction_free(tr);
1237 return 0;
1238
1239 tr_abort:
1240 transaction_abort(tr);
1241 transaction_free(tr);
1242 return r;
1243 }
1244
1245 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1246 Unit *unit;
1247 int r;
1248
1249 assert(m);
1250 assert(type < _JOB_TYPE_MAX);
1251 assert(name);
1252 assert(mode < _JOB_MODE_MAX);
1253
1254 r = manager_load_unit(m, name, NULL, NULL, &unit);
1255 if (r < 0)
1256 return r;
1257
1258 return manager_add_job(m, type, unit, mode, override, e, _ret);
1259 }
1260
1261 Job *manager_get_job(Manager *m, uint32_t id) {
1262 assert(m);
1263
1264 return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1265 }
1266
1267 Unit *manager_get_unit(Manager *m, const char *name) {
1268 assert(m);
1269 assert(name);
1270
1271 return hashmap_get(m->units, name);
1272 }
1273
1274 unsigned manager_dispatch_load_queue(Manager *m) {
1275 Unit *u;
1276 unsigned n = 0;
1277
1278 assert(m);
1279
1280 /* Make sure we are not run recursively */
1281 if (m->dispatching_load_queue)
1282 return 0;
1283
1284 m->dispatching_load_queue = true;
1285
1286 /* Dispatches the load queue. Takes a unit from the queue and
1287 * tries to load its data until the queue is empty */
1288
1289 while ((u = m->load_queue)) {
1290 assert(u->in_load_queue);
1291
1292 unit_load(u);
1293 n++;
1294 }
1295
1296 m->dispatching_load_queue = false;
1297 return n;
1298 }
1299
1300 int manager_load_unit_prepare(
1301 Manager *m,
1302 const char *name,
1303 const char *path,
1304 sd_bus_error *e,
1305 Unit **_ret) {
1306
1307 Unit *ret;
1308 UnitType t;
1309 int r;
1310
1311 assert(m);
1312 assert(name || path);
1313
1314 /* This will prepare the unit for loading, but not actually
1315 * load anything from disk. */
1316
1317 if (path && !is_path(path))
1318 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1319
1320 if (!name)
1321 name = basename(path);
1322
1323 t = unit_name_to_type(name);
1324
1325 if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
1326 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1327
1328 ret = manager_get_unit(m, name);
1329 if (ret) {
1330 *_ret = ret;
1331 return 1;
1332 }
1333
1334 ret = unit_new(m, unit_vtable[t]->object_size);
1335 if (!ret)
1336 return -ENOMEM;
1337
1338 if (path) {
1339 ret->fragment_path = strdup(path);
1340 if (!ret->fragment_path) {
1341 unit_free(ret);
1342 return -ENOMEM;
1343 }
1344 }
1345
1346 r = unit_add_name(ret, name);
1347 if (r < 0) {
1348 unit_free(ret);
1349 return r;
1350 }
1351
1352 unit_add_to_load_queue(ret);
1353 unit_add_to_dbus_queue(ret);
1354 unit_add_to_gc_queue(ret);
1355
1356 if (_ret)
1357 *_ret = ret;
1358
1359 return 0;
1360 }
1361
1362 int manager_load_unit(
1363 Manager *m,
1364 const char *name,
1365 const char *path,
1366 sd_bus_error *e,
1367 Unit **_ret) {
1368
1369 int r;
1370
1371 assert(m);
1372
1373 /* This will load the service information files, but not actually
1374 * start any services or anything. */
1375
1376 r = manager_load_unit_prepare(m, name, path, e, _ret);
1377 if (r != 0)
1378 return r;
1379
1380 manager_dispatch_load_queue(m);
1381
1382 if (_ret)
1383 *_ret = unit_follow_merge(*_ret);
1384
1385 return 0;
1386 }
1387
1388 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1389 Iterator i;
1390 Job *j;
1391
1392 assert(s);
1393 assert(f);
1394
1395 HASHMAP_FOREACH(j, s->jobs, i)
1396 job_dump(j, f, prefix);
1397 }
1398
1399 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1400 Iterator i;
1401 Unit *u;
1402 const char *t;
1403
1404 assert(s);
1405 assert(f);
1406
1407 HASHMAP_FOREACH_KEY(u, t, s->units, i)
1408 if (u->id == t)
1409 unit_dump(u, f, prefix);
1410 }
1411
1412 void manager_clear_jobs(Manager *m) {
1413 Job *j;
1414
1415 assert(m);
1416
1417 while ((j = hashmap_first(m->jobs)))
1418 /* No need to recurse. We're cancelling all jobs. */
1419 job_finish_and_invalidate(j, JOB_CANCELED, false);
1420 }
1421
1422 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1423 Manager *m = userdata;
1424 Job *j;
1425
1426 assert(source);
1427 assert(m);
1428
1429 while ((j = m->run_queue)) {
1430 assert(j->installed);
1431 assert(j->in_run_queue);
1432
1433 job_run_and_invalidate(j);
1434 }
1435
1436 if (m->n_running_jobs > 0)
1437 manager_watch_jobs_in_progress(m);
1438
1439 if (m->n_on_console > 0)
1440 manager_watch_idle_pipe(m);
1441
1442 return 1;
1443 }
1444
1445 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1446 Job *j;
1447 Unit *u;
1448 unsigned n = 0;
1449
1450 assert(m);
1451
1452 if (m->dispatching_dbus_queue)
1453 return 0;
1454
1455 m->dispatching_dbus_queue = true;
1456
1457 while ((u = m->dbus_unit_queue)) {
1458 assert(u->in_dbus_queue);
1459
1460 bus_unit_send_change_signal(u);
1461 n++;
1462 }
1463
1464 while ((j = m->dbus_job_queue)) {
1465 assert(j->in_dbus_queue);
1466
1467 bus_job_send_change_signal(j);
1468 n++;
1469 }
1470
1471 m->dispatching_dbus_queue = false;
1472
1473 if (m->send_reloading_done) {
1474 m->send_reloading_done = false;
1475
1476 bus_manager_send_reloading(m, false);
1477 }
1478
1479 if (m->queued_message)
1480 bus_send_queued_message(m);
1481
1482 return n;
1483 }
1484
1485 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n, FDSet *fds) {
1486 _cleanup_strv_free_ char **tags = NULL;
1487
1488 assert(m);
1489 assert(u);
1490 assert(buf);
1491 assert(n > 0);
1492
1493 tags = strv_split(buf, "\n\r");
1494 if (!tags) {
1495 log_oom();
1496 return;
1497 }
1498
1499 if (UNIT_VTABLE(u)->notify_message)
1500 UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
1501 else
1502 log_unit_debug(u, "Got notification message for unit. Ignoring.");
1503 }
1504
1505 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1506 Manager *m = userdata;
1507 ssize_t n;
1508 int r;
1509
1510 assert(m);
1511 assert(m->notify_fd == fd);
1512
1513 if (revents != EPOLLIN) {
1514 log_warning("Got unexpected poll event for notify fd.");
1515 return 0;
1516 }
1517
1518 for (;;) {
1519 _cleanup_fdset_free_ FDSet *fds = NULL;
1520 char buf[NOTIFY_BUFFER_MAX+1];
1521 struct iovec iovec = {
1522 .iov_base = buf,
1523 .iov_len = sizeof(buf)-1,
1524 };
1525 union {
1526 struct cmsghdr cmsghdr;
1527 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1528 CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1529 } control = {};
1530 struct msghdr msghdr = {
1531 .msg_iov = &iovec,
1532 .msg_iovlen = 1,
1533 .msg_control = &control,
1534 .msg_controllen = sizeof(control),
1535 };
1536 struct cmsghdr *cmsg;
1537 struct ucred *ucred = NULL;
1538 bool found = false;
1539 Unit *u1, *u2, *u3;
1540 int *fd_array = NULL;
1541 unsigned n_fds = 0;
1542
1543 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1544 if (n < 0) {
1545 if (errno == EAGAIN || errno == EINTR)
1546 break;
1547
1548 return -errno;
1549 }
1550
1551 CMSG_FOREACH(cmsg, &msghdr) {
1552 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1553
1554 fd_array = (int*) CMSG_DATA(cmsg);
1555 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1556
1557 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1558 cmsg->cmsg_type == SCM_CREDENTIALS &&
1559 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1560
1561 ucred = (struct ucred*) CMSG_DATA(cmsg);
1562 }
1563 }
1564
1565 if (n_fds > 0) {
1566 assert(fd_array);
1567
1568 r = fdset_new_array(&fds, fd_array, n_fds);
1569 if (r < 0) {
1570 close_many(fd_array, n_fds);
1571 return log_oom();
1572 }
1573 }
1574
1575 if (!ucred || ucred->pid <= 0) {
1576 log_warning("Received notify message without valid credentials. Ignoring.");
1577 continue;
1578 }
1579
1580 if ((size_t) n >= sizeof(buf)) {
1581 log_warning("Received notify message exceeded maximum size. Ignoring.");
1582 continue;
1583 }
1584
1585 buf[n] = 0;
1586
1587 /* Notify every unit that might be interested, but try
1588 * to avoid notifying the same one multiple times. */
1589 u1 = manager_get_unit_by_pid_cgroup(m, ucred->pid);
1590 if (u1) {
1591 manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
1592 found = true;
1593 }
1594
1595 u2 = hashmap_get(m->watch_pids1, PID_TO_PTR(ucred->pid));
1596 if (u2 && u2 != u1) {
1597 manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
1598 found = true;
1599 }
1600
1601 u3 = hashmap_get(m->watch_pids2, PID_TO_PTR(ucred->pid));
1602 if (u3 && u3 != u2 && u3 != u1) {
1603 manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
1604 found = true;
1605 }
1606
1607 if (!found)
1608 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1609
1610 if (fdset_size(fds) > 0)
1611 log_warning("Got auxiliary fds with notification message, closing all.");
1612 }
1613
1614 return 0;
1615 }
1616
1617 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1618 assert(m);
1619 assert(u);
1620 assert(si);
1621
1622 log_unit_debug(u, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1623
1624 unit_unwatch_pid(u, si->si_pid);
1625 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1626 }
1627
1628 static int manager_dispatch_sigchld(Manager *m) {
1629 assert(m);
1630
1631 for (;;) {
1632 siginfo_t si = {};
1633
1634 /* First we call waitd() for a PID and do not reap the
1635 * zombie. That way we can still access /proc/$PID for
1636 * it while it is a zombie. */
1637 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1638
1639 if (errno == ECHILD)
1640 break;
1641
1642 if (errno == EINTR)
1643 continue;
1644
1645 return -errno;
1646 }
1647
1648 if (si.si_pid <= 0)
1649 break;
1650
1651 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1652 _cleanup_free_ char *name = NULL;
1653 Unit *u1, *u2, *u3;
1654
1655 get_process_comm(si.si_pid, &name);
1656
1657 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1658 si.si_pid, strna(name),
1659 sigchld_code_to_string(si.si_code),
1660 si.si_status,
1661 strna(si.si_code == CLD_EXITED
1662 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1663 : signal_to_string(si.si_status)));
1664
1665 /* And now figure out the unit this belongs
1666 * to, it might be multiple... */
1667 u1 = manager_get_unit_by_pid_cgroup(m, si.si_pid);
1668 if (u1)
1669 invoke_sigchld_event(m, u1, &si);
1670 u2 = hashmap_get(m->watch_pids1, PID_TO_PTR(si.si_pid));
1671 if (u2 && u2 != u1)
1672 invoke_sigchld_event(m, u2, &si);
1673 u3 = hashmap_get(m->watch_pids2, PID_TO_PTR(si.si_pid));
1674 if (u3 && u3 != u2 && u3 != u1)
1675 invoke_sigchld_event(m, u3, &si);
1676 }
1677
1678 /* And now, we actually reap the zombie. */
1679 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1680 if (errno == EINTR)
1681 continue;
1682
1683 return -errno;
1684 }
1685 }
1686
1687 return 0;
1688 }
1689
1690 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1691 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1692 int r;
1693
1694 log_debug("Activating special unit %s", name);
1695
1696 r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1697 if (r < 0)
1698 log_error("Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1699
1700 return r;
1701 }
1702
1703 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1704 Manager *m = userdata;
1705 ssize_t n;
1706 struct signalfd_siginfo sfsi;
1707 bool sigchld = false;
1708 int r;
1709
1710 assert(m);
1711 assert(m->signal_fd == fd);
1712
1713 if (revents != EPOLLIN) {
1714 log_warning("Got unexpected events from signal file descriptor.");
1715 return 0;
1716 }
1717
1718 for (;;) {
1719 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1720 if (n != sizeof(sfsi)) {
1721
1722 if (n >= 0)
1723 return -EIO;
1724
1725 if (errno == EINTR || errno == EAGAIN)
1726 break;
1727
1728 return -errno;
1729 }
1730
1731 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1732 (sfsi.ssi_signo == SIGTERM && m->running_as == MANAGER_USER)
1733 ? LOG_DEBUG : LOG_INFO,
1734 &sfsi);
1735
1736 switch (sfsi.ssi_signo) {
1737
1738 case SIGCHLD:
1739 sigchld = true;
1740 break;
1741
1742 case SIGTERM:
1743 if (m->running_as == MANAGER_SYSTEM) {
1744 /* This is for compatibility with the
1745 * original sysvinit */
1746 m->exit_code = MANAGER_REEXECUTE;
1747 break;
1748 }
1749
1750 /* Fall through */
1751
1752 case SIGINT:
1753 if (m->running_as == MANAGER_SYSTEM) {
1754
1755 /* If the user presses C-A-D more than
1756 * 7 times within 2s, we reboot
1757 * immediately. */
1758
1759 if (ratelimit_test(&m->ctrl_alt_del_ratelimit))
1760 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1761 else {
1762 log_notice("Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1763 status_printf(NULL, true, false, "Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1764 m->exit_code = MANAGER_REBOOT;
1765 }
1766
1767 break;
1768 }
1769
1770 /* Run the exit target if there is one, if not, just exit. */
1771 if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1772 m->exit_code = MANAGER_EXIT;
1773 return 0;
1774 }
1775
1776 break;
1777
1778 case SIGWINCH:
1779 if (m->running_as == MANAGER_SYSTEM)
1780 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1781
1782 /* This is a nop on non-init */
1783 break;
1784
1785 case SIGPWR:
1786 if (m->running_as == MANAGER_SYSTEM)
1787 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1788
1789 /* This is a nop on non-init */
1790 break;
1791
1792 case SIGUSR1: {
1793 Unit *u;
1794
1795 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1796
1797 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1798 log_info("Trying to reconnect to bus...");
1799 bus_init(m, true);
1800 }
1801
1802 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1803 log_info("Loading D-Bus service...");
1804 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1805 }
1806
1807 break;
1808 }
1809
1810 case SIGUSR2: {
1811 _cleanup_free_ char *dump = NULL;
1812 _cleanup_fclose_ FILE *f = NULL;
1813 size_t size;
1814
1815 f = open_memstream(&dump, &size);
1816 if (!f) {
1817 log_warning_errno(errno, "Failed to allocate memory stream: %m");
1818 break;
1819 }
1820
1821 manager_dump_units(m, f, "\t");
1822 manager_dump_jobs(m, f, "\t");
1823
1824 r = fflush_and_check(f);
1825 if (r < 0) {
1826 log_warning_errno(r, "Failed to write status stream: %m");
1827 break;
1828 }
1829
1830 log_dump(LOG_INFO, dump);
1831 break;
1832 }
1833
1834 case SIGHUP:
1835 m->exit_code = MANAGER_RELOAD;
1836 break;
1837
1838 default: {
1839
1840 /* Starting SIGRTMIN+0 */
1841 static const char * const target_table[] = {
1842 [0] = SPECIAL_DEFAULT_TARGET,
1843 [1] = SPECIAL_RESCUE_TARGET,
1844 [2] = SPECIAL_EMERGENCY_TARGET,
1845 [3] = SPECIAL_HALT_TARGET,
1846 [4] = SPECIAL_POWEROFF_TARGET,
1847 [5] = SPECIAL_REBOOT_TARGET,
1848 [6] = SPECIAL_KEXEC_TARGET
1849 };
1850
1851 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1852 static const ManagerExitCode code_table[] = {
1853 [0] = MANAGER_HALT,
1854 [1] = MANAGER_POWEROFF,
1855 [2] = MANAGER_REBOOT,
1856 [3] = MANAGER_KEXEC
1857 };
1858
1859 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1860 (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1861 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1862 manager_start_target(m, target_table[idx],
1863 (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1864 break;
1865 }
1866
1867 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1868 (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1869 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1870 break;
1871 }
1872
1873 switch (sfsi.ssi_signo - SIGRTMIN) {
1874
1875 case 20:
1876 log_debug("Enabling showing of status.");
1877 manager_set_show_status(m, SHOW_STATUS_YES);
1878 break;
1879
1880 case 21:
1881 log_debug("Disabling showing of status.");
1882 manager_set_show_status(m, SHOW_STATUS_NO);
1883 break;
1884
1885 case 22:
1886 log_set_max_level(LOG_DEBUG);
1887 log_notice("Setting log level to debug.");
1888 break;
1889
1890 case 23:
1891 log_set_max_level(LOG_INFO);
1892 log_notice("Setting log level to info.");
1893 break;
1894
1895 case 24:
1896 if (m->running_as == MANAGER_USER) {
1897 m->exit_code = MANAGER_EXIT;
1898 return 0;
1899 }
1900
1901 /* This is a nop on init */
1902 break;
1903
1904 case 26:
1905 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1906 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1907 log_notice("Setting log target to journal-or-kmsg.");
1908 break;
1909
1910 case 27:
1911 log_set_target(LOG_TARGET_CONSOLE);
1912 log_notice("Setting log target to console.");
1913 break;
1914
1915 case 28:
1916 log_set_target(LOG_TARGET_KMSG);
1917 log_notice("Setting log target to kmsg.");
1918 break;
1919
1920 default:
1921 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1922 }
1923 }
1924 }
1925 }
1926
1927 if (sigchld)
1928 manager_dispatch_sigchld(m);
1929
1930 return 0;
1931 }
1932
1933 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1934 Manager *m = userdata;
1935 Iterator i;
1936 Unit *u;
1937
1938 assert(m);
1939 assert(m->time_change_fd == fd);
1940
1941 log_struct(LOG_INFO,
1942 LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1943 LOG_MESSAGE("Time has been changed"),
1944 NULL);
1945
1946 /* Restart the watch */
1947 m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1948 m->time_change_fd = safe_close(m->time_change_fd);
1949
1950 manager_setup_time_change(m);
1951
1952 HASHMAP_FOREACH(u, m->units, i)
1953 if (UNIT_VTABLE(u)->time_change)
1954 UNIT_VTABLE(u)->time_change(u);
1955
1956 return 0;
1957 }
1958
1959 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1960 Manager *m = userdata;
1961
1962 assert(m);
1963 assert(m->idle_pipe[2] == fd);
1964
1965 m->no_console_output = m->n_on_console > 0;
1966
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() > 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() <= 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 assert(m);
2680
2681 if (m->n_reloading > 0)
2682 return;
2683
2684 /* Verify that we are actually running currently. Initially
2685 * the exit code is set to invalid, and during operation it is
2686 * then set to MANAGER_OK */
2687 if (m->exit_code != MANAGER_OK)
2688 return;
2689
2690 if (hashmap_size(m->jobs) > 0) {
2691 if (m->jobs_in_progress_event_source)
2692 /* Ignore any failure, this is only for feedback */
2693 (void) sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2694
2695 return;
2696 }
2697
2698 manager_flip_auto_status(m, false);
2699
2700 /* Notify Type=idle units that we are done now */
2701 manager_close_idle_pipe(m);
2702
2703 /* Turn off confirm spawn now */
2704 m->confirm_spawn = false;
2705
2706 /* No need to update ask password status when we're going non-interactive */
2707 manager_close_ask_password(m);
2708
2709 /* This is no longer the first boot */
2710 manager_set_first_boot(m, false);
2711
2712 if (dual_timestamp_is_set(&m->finish_timestamp))
2713 return;
2714
2715 dual_timestamp_get(&m->finish_timestamp);
2716
2717 manager_notify_finished(m);
2718
2719 manager_invalidate_startup_units(m);
2720 }
2721
2722 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2723 char *p;
2724 int r;
2725
2726 assert(m);
2727 assert(generator);
2728 assert(name);
2729
2730 if (*generator)
2731 return 0;
2732
2733 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
2734 /* systemd --system, not running --test */
2735
2736 p = strappend("/run/systemd/", name);
2737 if (!p)
2738 return log_oom();
2739
2740 r = mkdir_p_label(p, 0755);
2741 if (r < 0) {
2742 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2743 free(p);
2744 return r;
2745 }
2746 } else if (m->running_as == MANAGER_USER) {
2747 const char *s = NULL;
2748
2749 s = getenv("XDG_RUNTIME_DIR");
2750 if (!s)
2751 return -EINVAL;
2752 p = strjoin(s, "/systemd/", name, NULL);
2753 if (!p)
2754 return log_oom();
2755
2756 r = mkdir_p_label(p, 0755);
2757 if (r < 0) {
2758 log_error_errno(r, "Failed to create generator directory %s: %m", p);
2759 free(p);
2760 return r;
2761 }
2762 } else {
2763 /* systemd --system --test */
2764
2765 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2766 if (!p)
2767 return log_oom();
2768
2769 if (!mkdtemp(p)) {
2770 log_error_errno(errno, "Failed to create generator directory %s: %m",
2771 p);
2772 free(p);
2773 return -errno;
2774 }
2775 }
2776
2777 *generator = p;
2778 return 0;
2779 }
2780
2781 static void trim_generator_dir(Manager *m, char **generator) {
2782 assert(m);
2783 assert(generator);
2784
2785 if (!*generator)
2786 return;
2787
2788 if (rmdir(*generator) >= 0)
2789 *generator = mfree(*generator);
2790
2791 return;
2792 }
2793
2794 static int manager_run_generators(Manager *m) {
2795 _cleanup_strv_free_ char **paths = NULL;
2796 const char *argv[5];
2797 char **path;
2798 int r;
2799
2800 assert(m);
2801
2802 if (m->test_run)
2803 return 0;
2804
2805 paths = generator_paths(m->running_as);
2806 if (!paths)
2807 return log_oom();
2808
2809 /* Optimize by skipping the whole process by not creating output directories
2810 * if no generators are found. */
2811 STRV_FOREACH(path, paths) {
2812 r = access(*path, F_OK);
2813 if (r == 0)
2814 goto found;
2815 if (errno != ENOENT)
2816 log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
2817 }
2818 return 0;
2819
2820 found:
2821 r = create_generator_dir(m, &m->generator_unit_path, "generator");
2822 if (r < 0)
2823 goto finish;
2824
2825 r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2826 if (r < 0)
2827 goto finish;
2828
2829 r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2830 if (r < 0)
2831 goto finish;
2832
2833 argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2834 argv[1] = m->generator_unit_path;
2835 argv[2] = m->generator_unit_path_early;
2836 argv[3] = m->generator_unit_path_late;
2837 argv[4] = NULL;
2838
2839 RUN_WITH_UMASK(0022)
2840 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
2841
2842 finish:
2843 trim_generator_dir(m, &m->generator_unit_path);
2844 trim_generator_dir(m, &m->generator_unit_path_early);
2845 trim_generator_dir(m, &m->generator_unit_path_late);
2846 return r;
2847 }
2848
2849 static void remove_generator_dir(Manager *m, char **generator) {
2850 assert(m);
2851 assert(generator);
2852
2853 if (!*generator)
2854 return;
2855
2856 strv_remove(m->lookup_paths.unit_path, *generator);
2857 (void) rm_rf(*generator, REMOVE_ROOT);
2858
2859 *generator = mfree(*generator);
2860 }
2861
2862 static void manager_undo_generators(Manager *m) {
2863 assert(m);
2864
2865 remove_generator_dir(m, &m->generator_unit_path);
2866 remove_generator_dir(m, &m->generator_unit_path_early);
2867 remove_generator_dir(m, &m->generator_unit_path_late);
2868 }
2869
2870 int manager_environment_add(Manager *m, char **minus, char **plus) {
2871 char **a = NULL, **b = NULL, **l;
2872 assert(m);
2873
2874 l = m->environment;
2875
2876 if (!strv_isempty(minus)) {
2877 a = strv_env_delete(l, 1, minus);
2878 if (!a)
2879 return -ENOMEM;
2880
2881 l = a;
2882 }
2883
2884 if (!strv_isempty(plus)) {
2885 b = strv_env_merge(2, l, plus);
2886 if (!b) {
2887 strv_free(a);
2888 return -ENOMEM;
2889 }
2890
2891 l = b;
2892 }
2893
2894 if (m->environment != l)
2895 strv_free(m->environment);
2896 if (a != l)
2897 strv_free(a);
2898 if (b != l)
2899 strv_free(b);
2900
2901 m->environment = l;
2902 manager_clean_environment(m);
2903 strv_sort(m->environment);
2904
2905 return 0;
2906 }
2907
2908 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2909 int i;
2910
2911 assert(m);
2912
2913 for (i = 0; i < _RLIMIT_MAX; i++) {
2914 if (!default_rlimit[i])
2915 continue;
2916
2917 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2918 if (!m->rlimit[i])
2919 return -ENOMEM;
2920 }
2921
2922 return 0;
2923 }
2924
2925 void manager_recheck_journal(Manager *m) {
2926 Unit *u;
2927
2928 assert(m);
2929
2930 if (m->running_as != MANAGER_SYSTEM)
2931 return;
2932
2933 u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2934 if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2935 log_close_journal();
2936 return;
2937 }
2938
2939 u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2940 if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2941 log_close_journal();
2942 return;
2943 }
2944
2945 /* Hmm, OK, so the socket is fully up and the service is up
2946 * too, then let's make use of the thing. */
2947 log_open();
2948 }
2949
2950 void manager_set_show_status(Manager *m, ShowStatus mode) {
2951 assert(m);
2952 assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2953
2954 if (m->running_as != MANAGER_SYSTEM)
2955 return;
2956
2957 m->show_status = mode;
2958
2959 if (mode > 0)
2960 (void) touch("/run/systemd/show-status");
2961 else
2962 (void) unlink("/run/systemd/show-status");
2963 }
2964
2965 static bool manager_get_show_status(Manager *m, StatusType type) {
2966 assert(m);
2967
2968 if (m->running_as != MANAGER_SYSTEM)
2969 return false;
2970
2971 if (m->no_console_output)
2972 return false;
2973
2974 if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2975 return false;
2976
2977 /* If we cannot find out the status properly, just proceed. */
2978 if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2979 return false;
2980
2981 if (m->show_status > 0)
2982 return true;
2983
2984 return false;
2985 }
2986
2987 void manager_set_first_boot(Manager *m, bool b) {
2988 assert(m);
2989
2990 if (m->running_as != MANAGER_SYSTEM)
2991 return;
2992
2993 if (m->first_boot != (int) b) {
2994 if (b)
2995 (void) touch("/run/systemd/first-boot");
2996 else
2997 (void) unlink("/run/systemd/first-boot");
2998 }
2999
3000 m->first_boot = b;
3001 }
3002
3003 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
3004 va_list ap;
3005
3006 /* If m is NULL, assume we're after shutdown and let the messages through. */
3007
3008 if (m && !manager_get_show_status(m, type))
3009 return;
3010
3011 /* XXX We should totally drop the check for ephemeral here
3012 * and thus effectively make 'Type=idle' pointless. */
3013 if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3014 return;
3015
3016 va_start(ap, format);
3017 status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3018 va_end(ap);
3019 }
3020
3021 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3022 char p[strlen(path)+1];
3023
3024 assert(m);
3025 assert(path);
3026
3027 strcpy(p, path);
3028 path_kill_slashes(p);
3029
3030 return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3031 }
3032
3033 const char *manager_get_runtime_prefix(Manager *m) {
3034 assert(m);
3035
3036 return m->running_as == MANAGER_SYSTEM ?
3037 "/run" :
3038 getenv("XDG_RUNTIME_DIR");
3039 }
3040
3041 int manager_update_failed_units(Manager *m, Unit *u, bool failed) {
3042 unsigned size;
3043 int r;
3044
3045 assert(m);
3046 assert(u->manager == m);
3047
3048 size = set_size(m->failed_units);
3049
3050 if (failed) {
3051 r = set_ensure_allocated(&m->failed_units, NULL);
3052 if (r < 0)
3053 return log_oom();
3054
3055 if (set_put(m->failed_units, u) < 0)
3056 return log_oom();
3057 } else
3058 (void) set_remove(m->failed_units, u);
3059
3060 if (set_size(m->failed_units) != size)
3061 bus_manager_send_change_signal(m);
3062
3063 return 0;
3064 }
3065
3066 ManagerState manager_state(Manager *m) {
3067 Unit *u;
3068
3069 assert(m);
3070
3071 /* Did we ever finish booting? If not then we are still starting up */
3072 if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3073
3074 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3075 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3076 return MANAGER_INITIALIZING;
3077
3078 return MANAGER_STARTING;
3079 }
3080
3081 /* Is the special shutdown target queued? If so, we are in shutdown state */
3082 u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3083 if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3084 return MANAGER_STOPPING;
3085
3086 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3087 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3088 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3089 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3090 return MANAGER_MAINTENANCE;
3091
3092 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3093 if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3094 (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3095 return MANAGER_MAINTENANCE;
3096
3097 /* Are there any failed units? If so, we are in degraded mode */
3098 if (set_size(m->failed_units) > 0)
3099 return MANAGER_DEGRADED;
3100
3101 return MANAGER_RUNNING;
3102 }
3103
3104 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3105 [MANAGER_INITIALIZING] = "initializing",
3106 [MANAGER_STARTING] = "starting",
3107 [MANAGER_RUNNING] = "running",
3108 [MANAGER_DEGRADED] = "degraded",
3109 [MANAGER_MAINTENANCE] = "maintenance",
3110 [MANAGER_STOPPING] = "stopping",
3111 };
3112
3113 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
Unnamed repository; edit this file 'description' to name the repository.