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