]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/manager.c
projects / thirdparty / systemd.git / blob
? search:


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