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