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