chiark / gitweb /
fix a couple of things found with the llvm static analyzer
[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
40 #ifdef HAVE_AUDIT
41 #include <libaudit.h>
42 #endif
43
44 #include <systemd/sd-daemon.h>
45
46 #include "manager.h"
47 #include "hashmap.h"
48 #include "macro.h"
49 #include "strv.h"
50 #include "log.h"
51 #include "util.h"
52 #include "mkdir.h"
53 #include "ratelimit.h"
54 #include "cgroup.h"
55 #include "mount-setup.h"
56 #include "unit-name.h"
57 #include "dbus-unit.h"
58 #include "dbus-job.h"
59 #include "missing.h"
60 #include "path-lookup.h"
61 #include "special.h"
62 #include "bus-errors.h"
63 #include "exit-status.h"
64 #include "virt.h"
65 #include "watchdog.h"
66
67 /* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
68 #define GC_QUEUE_ENTRIES_MAX 16
69
70 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
71 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
72
73 /* Where clients shall send notification messages to */
74 #define NOTIFY_SOCKET_SYSTEM "/run/systemd/notify"
75 #define NOTIFY_SOCKET_USER "@/org/freedesktop/systemd1/notify"
76
77 static int manager_setup_notify(Manager *m) {
78         union {
79                 struct sockaddr sa;
80                 struct sockaddr_un un;
81         } sa;
82         struct epoll_event ev;
83         int one = 1, r;
84         mode_t u;
85
86         assert(m);
87
88         m->notify_watch.type = WATCH_NOTIFY;
89         if ((m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
90                 log_error("Failed to allocate notification socket: %m");
91                 return -errno;
92         }
93
94         zero(sa);
95         sa.sa.sa_family = AF_UNIX;
96
97         if (getpid() != 1)
98                 snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET_USER "/%llu", random_ull());
99         else {
100                 unlink(NOTIFY_SOCKET_SYSTEM);
101                 strncpy(sa.un.sun_path, NOTIFY_SOCKET_SYSTEM, sizeof(sa.un.sun_path));
102         }
103
104         if (sa.un.sun_path[0] == '@')
105                 sa.un.sun_path[0] = 0;
106
107         u = umask(0111);
108         r = bind(m->notify_watch.fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
109         umask(u);
110
111         if (r < 0) {
112                 log_error("bind() failed: %m");
113                 return -errno;
114         }
115
116         if (setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0) {
117                 log_error("SO_PASSCRED failed: %m");
118                 return -errno;
119         }
120
121         zero(ev);
122         ev.events = EPOLLIN;
123         ev.data.ptr = &m->notify_watch;
124
125         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev) < 0)
126                 return -errno;
127
128         if (sa.un.sun_path[0] == 0)
129                 sa.un.sun_path[0] = '@';
130
131         if (!(m->notify_socket = strdup(sa.un.sun_path)))
132                 return -ENOMEM;
133
134         log_debug("Using notification socket %s", m->notify_socket);
135
136         return 0;
137 }
138
139 static int enable_special_signals(Manager *m) {
140         int fd;
141
142         assert(m);
143
144         /* Enable that we get SIGINT on control-alt-del */
145         if (reboot(RB_DISABLE_CAD) < 0)
146                 log_warning("Failed to enable ctrl-alt-del handling: %m");
147
148         if ((fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC)) < 0)
149                 log_warning("Failed to open /dev/tty0: %m");
150         else {
151                 /* Enable that we get SIGWINCH on kbrequest */
152                 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
153                         log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
154
155                 close_nointr_nofail(fd);
156         }
157
158         return 0;
159 }
160
161 static int manager_setup_signals(Manager *m) {
162         sigset_t mask;
163         struct epoll_event ev;
164         struct sigaction sa;
165
166         assert(m);
167
168         /* We are not interested in SIGSTOP and friends. */
169         zero(sa);
170         sa.sa_handler = SIG_DFL;
171         sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
172         assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
173
174         assert_se(sigemptyset(&mask) == 0);
175
176         sigset_add_many(&mask,
177                         SIGCHLD,     /* Child died */
178                         SIGTERM,     /* Reexecute daemon */
179                         SIGHUP,      /* Reload configuration */
180                         SIGUSR1,     /* systemd/upstart: reconnect to D-Bus */
181                         SIGUSR2,     /* systemd: dump status */
182                         SIGINT,      /* Kernel sends us this on control-alt-del */
183                         SIGWINCH,    /* Kernel sends us this on kbrequest (alt-arrowup) */
184                         SIGPWR,      /* Some kernel drivers and upsd send us this on power failure */
185                         SIGRTMIN+0,  /* systemd: start default.target */
186                         SIGRTMIN+1,  /* systemd: isolate rescue.target */
187                         SIGRTMIN+2,  /* systemd: isolate emergency.target */
188                         SIGRTMIN+3,  /* systemd: start halt.target */
189                         SIGRTMIN+4,  /* systemd: start poweroff.target */
190                         SIGRTMIN+5,  /* systemd: start reboot.target */
191                         SIGRTMIN+6,  /* systemd: start kexec.target */
192                         SIGRTMIN+13, /* systemd: Immediate halt */
193                         SIGRTMIN+14, /* systemd: Immediate poweroff */
194                         SIGRTMIN+15, /* systemd: Immediate reboot */
195                         SIGRTMIN+16, /* systemd: Immediate kexec */
196                         SIGRTMIN+20, /* systemd: enable status messages */
197                         SIGRTMIN+21, /* systemd: disable status messages */
198                         SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
199                         SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
200                         SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
201                         SIGRTMIN+27, /* systemd: set log target to console */
202                         SIGRTMIN+28, /* systemd: set log target to kmsg */
203                         SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
204                         -1);
205         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
206
207         m->signal_watch.type = WATCH_SIGNAL;
208         if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
209                 return -errno;
210
211         zero(ev);
212         ev.events = EPOLLIN;
213         ev.data.ptr = &m->signal_watch;
214
215         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
216                 return -errno;
217
218         if (m->running_as == MANAGER_SYSTEM)
219                 return enable_special_signals(m);
220
221         return 0;
222 }
223
224 static void manager_strip_environment(Manager *m) {
225         assert(m);
226
227         /* Remove variables from the inherited set that are part of
228          * the container interface:
229          * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
230         strv_remove_prefix(m->environment, "container=");
231         strv_remove_prefix(m->environment, "container_");
232
233         /* Remove variables from the inherited set that are part of
234          * the initrd interface:
235          * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
236         strv_remove_prefix(m->environment, "RD_");
237 }
238
239 int manager_new(ManagerRunningAs running_as, Manager **_m) {
240         Manager *m;
241         int r = -ENOMEM;
242
243         assert(_m);
244         assert(running_as >= 0);
245         assert(running_as < _MANAGER_RUNNING_AS_MAX);
246
247         if (!(m = new0(Manager, 1)))
248                 return -ENOMEM;
249
250         dual_timestamp_get(&m->startup_timestamp);
251
252         m->running_as = running_as;
253         m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
254         m->exit_code = _MANAGER_EXIT_CODE_INVALID;
255         m->pin_cgroupfs_fd = -1;
256
257 #ifdef HAVE_AUDIT
258         m->audit_fd = -1;
259 #endif
260
261         m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_fd = m->dev_autofs_fd = m->swap_watch.fd = -1;
262         m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
263
264         m->environment = strv_copy(environ);
265         if (!m->environment)
266                 goto fail;
267
268         manager_strip_environment(m);
269
270         if (running_as == MANAGER_SYSTEM) {
271                 m->default_controllers = strv_new("cpu", NULL);
272                 if (!m->default_controllers)
273                         goto fail;
274         }
275
276         if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
277                 goto fail;
278
279         if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
280                 goto fail;
281
282         if (!(m->transaction_jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
283                 goto fail;
284
285         if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
286                 goto fail;
287
288         if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
289                 goto fail;
290
291         if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
292                 goto fail;
293
294         if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
295                 goto fail;
296
297         if ((r = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
298                 goto fail;
299
300         if ((r = manager_setup_signals(m)) < 0)
301                 goto fail;
302
303         if ((r = manager_setup_cgroup(m)) < 0)
304                 goto fail;
305
306         if ((r = manager_setup_notify(m)) < 0)
307                 goto fail;
308
309         /* Try to connect to the busses, if possible. */
310         if ((r = bus_init(m, running_as != MANAGER_SYSTEM)) < 0)
311                 goto fail;
312
313 #ifdef HAVE_AUDIT
314         if ((m->audit_fd = audit_open()) < 0 &&
315             /* If the kernel lacks netlink or audit support,
316              * don't worry about it. */
317             errno != EAFNOSUPPORT && errno != EPROTONOSUPPORT)
318                 log_error("Failed to connect to audit log: %m");
319 #endif
320
321         m->taint_usr = dir_is_empty("/usr") > 0;
322
323         *_m = m;
324         return 0;
325
326 fail:
327         manager_free(m);
328         return r;
329 }
330
331 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
332         Unit *u;
333         unsigned n = 0;
334
335         assert(m);
336
337         while ((u = m->cleanup_queue)) {
338                 assert(u->in_cleanup_queue);
339
340                 unit_free(u);
341                 n++;
342         }
343
344         return n;
345 }
346
347 enum {
348         GC_OFFSET_IN_PATH,  /* This one is on the path we were traveling */
349         GC_OFFSET_UNSURE,   /* No clue */
350         GC_OFFSET_GOOD,     /* We still need this unit */
351         GC_OFFSET_BAD,      /* We don't need this unit anymore */
352         _GC_OFFSET_MAX
353 };
354
355 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
356         Iterator i;
357         Unit *other;
358         bool is_bad;
359
360         assert(u);
361
362         if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
363             u->gc_marker == gc_marker + GC_OFFSET_BAD ||
364             u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
365                 return;
366
367         if (u->in_cleanup_queue)
368                 goto bad;
369
370         if (unit_check_gc(u))
371                 goto good;
372
373         u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
374
375         is_bad = true;
376
377         SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
378                 unit_gc_sweep(other, gc_marker);
379
380                 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
381                         goto good;
382
383                 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
384                         is_bad = false;
385         }
386
387         if (is_bad)
388                 goto bad;
389
390         /* We were unable to find anything out about this entry, so
391          * let's investigate it later */
392         u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
393         unit_add_to_gc_queue(u);
394         return;
395
396 bad:
397         /* We definitely know that this one is not useful anymore, so
398          * let's mark it for deletion */
399         u->gc_marker = gc_marker + GC_OFFSET_BAD;
400         unit_add_to_cleanup_queue(u);
401         return;
402
403 good:
404         u->gc_marker = gc_marker + GC_OFFSET_GOOD;
405 }
406
407 static unsigned manager_dispatch_gc_queue(Manager *m) {
408         Unit *u;
409         unsigned n = 0;
410         unsigned gc_marker;
411
412         assert(m);
413
414         if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
415             (m->gc_queue_timestamp <= 0 ||
416              (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
417                 return 0;
418
419         log_debug("Running GC...");
420
421         m->gc_marker += _GC_OFFSET_MAX;
422         if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
423                 m->gc_marker = 1;
424
425         gc_marker = m->gc_marker;
426
427         while ((u = m->gc_queue)) {
428                 assert(u->in_gc_queue);
429
430                 unit_gc_sweep(u, gc_marker);
431
432                 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
433                 u->in_gc_queue = false;
434
435                 n++;
436
437                 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
438                     u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
439                         log_debug("Collecting %s", u->id);
440                         u->gc_marker = gc_marker + GC_OFFSET_BAD;
441                         unit_add_to_cleanup_queue(u);
442                 }
443         }
444
445         m->n_in_gc_queue = 0;
446         m->gc_queue_timestamp = 0;
447
448         return n;
449 }
450
451 static void manager_clear_jobs_and_units(Manager *m) {
452         Job *j;
453         Unit *u;
454
455         assert(m);
456
457         while ((j = hashmap_first(m->transaction_jobs)))
458                 job_free(j);
459
460         while ((u = hashmap_first(m->units)))
461                 unit_free(u);
462
463         manager_dispatch_cleanup_queue(m);
464
465         assert(!m->load_queue);
466         assert(!m->run_queue);
467         assert(!m->dbus_unit_queue);
468         assert(!m->dbus_job_queue);
469         assert(!m->cleanup_queue);
470         assert(!m->gc_queue);
471
472         assert(hashmap_isempty(m->transaction_jobs));
473         assert(hashmap_isempty(m->jobs));
474         assert(hashmap_isempty(m->units));
475 }
476
477 void manager_free(Manager *m) {
478         UnitType c;
479
480         assert(m);
481
482         manager_clear_jobs_and_units(m);
483
484         for (c = 0; c < _UNIT_TYPE_MAX; c++)
485                 if (unit_vtable[c]->shutdown)
486                         unit_vtable[c]->shutdown(m);
487
488         /* If we reexecute ourselves, we keep the root cgroup
489          * around */
490         manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
491
492         manager_undo_generators(m);
493
494         bus_done(m);
495
496         hashmap_free(m->units);
497         hashmap_free(m->jobs);
498         hashmap_free(m->transaction_jobs);
499         hashmap_free(m->watch_pids);
500         hashmap_free(m->watch_bus);
501
502         if (m->epoll_fd >= 0)
503                 close_nointr_nofail(m->epoll_fd);
504         if (m->signal_watch.fd >= 0)
505                 close_nointr_nofail(m->signal_watch.fd);
506         if (m->notify_watch.fd >= 0)
507                 close_nointr_nofail(m->notify_watch.fd);
508
509 #ifdef HAVE_AUDIT
510         if (m->audit_fd >= 0)
511                 audit_close(m->audit_fd);
512 #endif
513
514         free(m->notify_socket);
515
516         lookup_paths_free(&m->lookup_paths);
517         strv_free(m->environment);
518
519         strv_free(m->default_controllers);
520
521         hashmap_free(m->cgroup_bondings);
522         set_free_free(m->unit_path_cache);
523
524         free(m);
525 }
526
527 int manager_enumerate(Manager *m) {
528         int r = 0, q;
529         UnitType c;
530
531         assert(m);
532
533         /* Let's ask every type to load all units from disk/kernel
534          * that it might know */
535         for (c = 0; c < _UNIT_TYPE_MAX; c++)
536                 if (unit_vtable[c]->enumerate)
537                         if ((q = unit_vtable[c]->enumerate(m)) < 0)
538                                 r = q;
539
540         manager_dispatch_load_queue(m);
541         return r;
542 }
543
544 int manager_coldplug(Manager *m) {
545         int r = 0, q;
546         Iterator i;
547         Unit *u;
548         char *k;
549
550         assert(m);
551
552         /* Then, let's set up their initial state. */
553         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
554
555                 /* ignore aliases */
556                 if (u->id != k)
557                         continue;
558
559                 if ((q = unit_coldplug(u)) < 0)
560                         r = q;
561         }
562
563         return r;
564 }
565
566 static void manager_build_unit_path_cache(Manager *m) {
567         char **i;
568         DIR *d = NULL;
569         int r;
570
571         assert(m);
572
573         set_free_free(m->unit_path_cache);
574
575         if (!(m->unit_path_cache = set_new(string_hash_func, string_compare_func))) {
576                 log_error("Failed to allocate unit path cache.");
577                 return;
578         }
579
580         /* This simply builds a list of files we know exist, so that
581          * we don't always have to go to disk */
582
583         STRV_FOREACH(i, m->lookup_paths.unit_path) {
584                 struct dirent *de;
585
586                 if (!(d = opendir(*i))) {
587                         log_error("Failed to open directory: %m");
588                         continue;
589                 }
590
591                 while ((de = readdir(d))) {
592                         char *p;
593
594                         if (ignore_file(de->d_name))
595                                 continue;
596
597                         p = join(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
598                         if (!p) {
599                                 r = -ENOMEM;
600                                 goto fail;
601                         }
602
603                         if ((r = set_put(m->unit_path_cache, p)) < 0) {
604                                 free(p);
605                                 goto fail;
606                         }
607                 }
608
609                 closedir(d);
610                 d = NULL;
611         }
612
613         return;
614
615 fail:
616         log_error("Failed to build unit path cache: %s", strerror(-r));
617
618         set_free_free(m->unit_path_cache);
619         m->unit_path_cache = NULL;
620
621         if (d)
622                 closedir(d);
623 }
624
625 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
626         int r, q;
627
628         assert(m);
629
630         manager_run_generators(m);
631
632         manager_build_unit_path_cache(m);
633
634         /* If we will deserialize make sure that during enumeration
635          * this is already known, so we increase the counter here
636          * already */
637         if (serialization)
638                 m->n_reloading ++;
639
640         /* First, enumerate what we can from all config files */
641         r = manager_enumerate(m);
642
643         /* Second, deserialize if there is something to deserialize */
644         if (serialization)
645                 if ((q = manager_deserialize(m, serialization, fds)) < 0)
646                         r = q;
647
648         /* Third, fire things up! */
649         if ((q = manager_coldplug(m)) < 0)
650                 r = q;
651
652         if (serialization) {
653                 assert(m->n_reloading > 0);
654                 m->n_reloading --;
655         }
656
657         return r;
658 }
659
660 static void transaction_delete_job(Manager *m, Job *j, bool delete_dependencies) {
661         assert(m);
662         assert(j);
663
664         /* Deletes one job from the transaction */
665
666         manager_transaction_unlink_job(m, j, delete_dependencies);
667
668         if (!j->installed)
669                 job_free(j);
670 }
671
672 static void transaction_delete_unit(Manager *m, Unit *u) {
673         Job *j;
674
675         /* Deletes all jobs associated with a certain unit from the
676          * transaction */
677
678         while ((j = hashmap_get(m->transaction_jobs, u)))
679                 transaction_delete_job(m, j, true);
680 }
681
682 static void transaction_clean_dependencies(Manager *m) {
683         Iterator i;
684         Job *j;
685
686         assert(m);
687
688         /* Drops all dependencies of all installed jobs */
689
690         HASHMAP_FOREACH(j, m->jobs, i) {
691                 while (j->subject_list)
692                         job_dependency_free(j->subject_list);
693                 while (j->object_list)
694                         job_dependency_free(j->object_list);
695         }
696
697         assert(!m->transaction_anchor);
698 }
699
700 static void transaction_abort(Manager *m) {
701         Job *j;
702
703         assert(m);
704
705         while ((j = hashmap_first(m->transaction_jobs)))
706                 if (j->installed)
707                         transaction_delete_job(m, j, true);
708                 else
709                         job_free(j);
710
711         assert(hashmap_isempty(m->transaction_jobs));
712
713         transaction_clean_dependencies(m);
714 }
715
716 static void transaction_find_jobs_that_matter_to_anchor(Manager *m, Job *j, unsigned generation) {
717         JobDependency *l;
718
719         assert(m);
720
721         /* A recursive sweep through the graph that marks all units
722          * that matter to the anchor job, i.e. are directly or
723          * indirectly a dependency of the anchor job via paths that
724          * are fully marked as mattering. */
725
726         if (j)
727                 l = j->subject_list;
728         else
729                 l = m->transaction_anchor;
730
731         LIST_FOREACH(subject, l, l) {
732
733                 /* This link does not matter */
734                 if (!l->matters)
735                         continue;
736
737                 /* This unit has already been marked */
738                 if (l->object->generation == generation)
739                         continue;
740
741                 l->object->matters_to_anchor = true;
742                 l->object->generation = generation;
743
744                 transaction_find_jobs_that_matter_to_anchor(m, l->object, generation);
745         }
746 }
747
748 static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, JobType t) {
749         JobDependency *l, *last;
750
751         assert(j);
752         assert(other);
753         assert(j->unit == other->unit);
754         assert(!j->installed);
755
756         /* Merges 'other' into 'j' and then deletes j. */
757
758         j->type = t;
759         j->state = JOB_WAITING;
760         j->override = j->override || other->override;
761
762         j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor;
763
764         /* Patch us in as new owner of the JobDependency objects */
765         last = NULL;
766         LIST_FOREACH(subject, l, other->subject_list) {
767                 assert(l->subject == other);
768                 l->subject = j;
769                 last = l;
770         }
771
772         /* Merge both lists */
773         if (last) {
774                 last->subject_next = j->subject_list;
775                 if (j->subject_list)
776                         j->subject_list->subject_prev = last;
777                 j->subject_list = other->subject_list;
778         }
779
780         /* Patch us in as new owner of the JobDependency objects */
781         last = NULL;
782         LIST_FOREACH(object, l, other->object_list) {
783                 assert(l->object == other);
784                 l->object = j;
785                 last = l;
786         }
787
788         /* Merge both lists */
789         if (last) {
790                 last->object_next = j->object_list;
791                 if (j->object_list)
792                         j->object_list->object_prev = last;
793                 j->object_list = other->object_list;
794         }
795
796         /* Kill the other job */
797         other->subject_list = NULL;
798         other->object_list = NULL;
799         transaction_delete_job(m, other, true);
800 }
801 static bool job_is_conflicted_by(Job *j) {
802         JobDependency *l;
803
804         assert(j);
805
806         /* Returns true if this job is pulled in by a least one
807          * ConflictedBy dependency. */
808
809         LIST_FOREACH(object, l, j->object_list)
810                 if (l->conflicts)
811                         return true;
812
813         return false;
814 }
815
816 static int delete_one_unmergeable_job(Manager *m, Job *j) {
817         Job *k;
818
819         assert(j);
820
821         /* Tries to delete one item in the linked list
822          * j->transaction_next->transaction_next->... that conflicts
823          * with another one, in an attempt to make an inconsistent
824          * transaction work. */
825
826         /* We rely here on the fact that if a merged with b does not
827          * merge with c, either a or b merge with c neither */
828         LIST_FOREACH(transaction, j, j)
829                 LIST_FOREACH(transaction, k, j->transaction_next) {
830                         Job *d;
831
832                         /* Is this one mergeable? Then skip it */
833                         if (job_type_is_mergeable(j->type, k->type))
834                                 continue;
835
836                         /* Ok, we found two that conflict, let's see if we can
837                          * drop one of them */
838                         if (!j->matters_to_anchor && !k->matters_to_anchor) {
839
840                                 /* Both jobs don't matter, so let's
841                                  * find the one that is smarter to
842                                  * remove. Let's think positive and
843                                  * rather remove stops then starts --
844                                  * except if something is being
845                                  * stopped because it is conflicted by
846                                  * another unit in which case we
847                                  * rather remove the start. */
848
849                                 log_debug("Looking at job %s/%s conflicted_by=%s", j->unit->id, job_type_to_string(j->type), yes_no(j->type == JOB_STOP && job_is_conflicted_by(j)));
850                                 log_debug("Looking at job %s/%s conflicted_by=%s", k->unit->id, job_type_to_string(k->type), yes_no(k->type == JOB_STOP && job_is_conflicted_by(k)));
851
852                                 if (j->type == JOB_STOP) {
853
854                                         if (job_is_conflicted_by(j))
855                                                 d = k;
856                                         else
857                                                 d = j;
858
859                                 } else if (k->type == JOB_STOP) {
860
861                                         if (job_is_conflicted_by(k))
862                                                 d = j;
863                                         else
864                                                 d = k;
865                                 } else
866                                         d = j;
867
868                         } else if (!j->matters_to_anchor)
869                                 d = j;
870                         else if (!k->matters_to_anchor)
871                                 d = k;
872                         else
873                                 return -ENOEXEC;
874
875                         /* Ok, we can drop one, so let's do so. */
876                         log_debug("Fixing conflicting jobs by deleting job %s/%s", d->unit->id, job_type_to_string(d->type));
877                         transaction_delete_job(m, d, true);
878                         return 0;
879                 }
880
881         return -EINVAL;
882 }
883
884 static int transaction_merge_jobs(Manager *m, DBusError *e) {
885         Job *j;
886         Iterator i;
887         int r;
888
889         assert(m);
890
891         /* First step, check whether any of the jobs for one specific
892          * task conflict. If so, try to drop one of them. */
893         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
894                 JobType t;
895                 Job *k;
896
897                 t = j->type;
898                 LIST_FOREACH(transaction, k, j->transaction_next) {
899                         if (job_type_merge(&t, k->type) >= 0)
900                                 continue;
901
902                         /* OK, we could not merge all jobs for this
903                          * action. Let's see if we can get rid of one
904                          * of them */
905
906                         if ((r = delete_one_unmergeable_job(m, j)) >= 0)
907                                 /* Ok, we managed to drop one, now
908                                  * let's ask our callers to call us
909                                  * again after garbage collecting */
910                                 return -EAGAIN;
911
912                         /* We couldn't merge anything. Failure */
913                         dbus_set_error(e, BUS_ERROR_TRANSACTION_JOBS_CONFLICTING, "Transaction contains conflicting jobs '%s' and '%s' for %s. Probably contradicting requirement dependencies configured.",
914                                        job_type_to_string(t), job_type_to_string(k->type), k->unit->id);
915                         return r;
916                 }
917         }
918
919         /* Second step, merge the jobs. */
920         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
921                 JobType t = j->type;
922                 Job *k;
923
924                 /* Merge all transactions */
925                 LIST_FOREACH(transaction, k, j->transaction_next)
926                         assert_se(job_type_merge(&t, k->type) == 0);
927
928                 /* If an active job is mergeable, merge it too */
929                 if (j->unit->job)
930                         job_type_merge(&t, j->unit->job->type); /* Might fail. Which is OK */
931
932                 while ((k = j->transaction_next)) {
933                         if (j->installed) {
934                                 transaction_merge_and_delete_job(m, k, j, t);
935                                 j = k;
936                         } else
937                                 transaction_merge_and_delete_job(m, j, k, t);
938                 }
939
940                 if (j->unit->job && !j->installed)
941                         transaction_merge_and_delete_job(m, j, j->unit->job, t);
942
943                 assert(!j->transaction_next);
944                 assert(!j->transaction_prev);
945         }
946
947         return 0;
948 }
949
950 static void transaction_drop_redundant(Manager *m) {
951         bool again;
952
953         assert(m);
954
955         /* Goes through the transaction and removes all jobs that are
956          * a noop */
957
958         do {
959                 Job *j;
960                 Iterator i;
961
962                 again = false;
963
964                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
965                         bool changes_something = false;
966                         Job *k;
967
968                         LIST_FOREACH(transaction, k, j) {
969
970                                 if (!job_is_anchor(k) &&
971                                     (k->installed || job_type_is_redundant(k->type, unit_active_state(k->unit))) &&
972                                     (!k->unit->job || !job_type_is_conflicting(k->type, k->unit->job->type)))
973                                         continue;
974
975                                 changes_something = true;
976                                 break;
977                         }
978
979                         if (changes_something)
980                                 continue;
981
982                         /* log_debug("Found redundant job %s/%s, dropping.", j->unit->id, job_type_to_string(j->type)); */
983                         transaction_delete_job(m, j, false);
984                         again = true;
985                         break;
986                 }
987
988         } while (again);
989 }
990
991 static bool unit_matters_to_anchor(Unit *u, Job *j) {
992         assert(u);
993         assert(!j->transaction_prev);
994
995         /* Checks whether at least one of the jobs for this unit
996          * matters to the anchor. */
997
998         LIST_FOREACH(transaction, j, j)
999                 if (j->matters_to_anchor)
1000                         return true;
1001
1002         return false;
1003 }
1004
1005 static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned generation, DBusError *e) {
1006         Iterator i;
1007         Unit *u;
1008         int r;
1009
1010         assert(m);
1011         assert(j);
1012         assert(!j->transaction_prev);
1013
1014         /* Does a recursive sweep through the ordering graph, looking
1015          * for a cycle. If we find cycle we try to break it. */
1016
1017         /* Have we seen this before? */
1018         if (j->generation == generation) {
1019                 Job *k, *delete;
1020
1021                 /* If the marker is NULL we have been here already and
1022                  * decided the job was loop-free from here. Hence
1023                  * shortcut things and return right-away. */
1024                 if (!j->marker)
1025                         return 0;
1026
1027                 /* So, the marker is not NULL and we already have been
1028                  * here. We have a cycle. Let's try to break it. We go
1029                  * backwards in our path and try to find a suitable
1030                  * job to remove. We use the marker to find our way
1031                  * back, since smart how we are we stored our way back
1032                  * in there. */
1033                 log_warning("Found ordering cycle on %s/%s", j->unit->id, job_type_to_string(j->type));
1034
1035                 delete = NULL;
1036                 for (k = from; k; k = ((k->generation == generation && k->marker != k) ? k->marker : NULL)) {
1037
1038                         log_info("Walked on cycle path to %s/%s", k->unit->id, job_type_to_string(k->type));
1039
1040                         if (!delete &&
1041                             !k->installed &&
1042                             !unit_matters_to_anchor(k->unit, k)) {
1043                                 /* Ok, we can drop this one, so let's
1044                                  * do so. */
1045                                 delete = k;
1046                         }
1047
1048                         /* Check if this in fact was the beginning of
1049                          * the cycle */
1050                         if (k == j)
1051                                 break;
1052                 }
1053
1054
1055                 if (delete) {
1056                         log_warning("Breaking ordering cycle by deleting job %s/%s", delete->unit->id, job_type_to_string(delete->type));
1057                         transaction_delete_unit(m, delete->unit);
1058                         return -EAGAIN;
1059                 }
1060
1061                 log_error("Unable to break cycle");
1062
1063                 dbus_set_error(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC, "Transaction order is cyclic. See system logs for details.");
1064                 return -ENOEXEC;
1065         }
1066
1067         /* Make the marker point to where we come from, so that we can
1068          * find our way backwards if we want to break a cycle. We use
1069          * a special marker for the beginning: we point to
1070          * ourselves. */
1071         j->marker = from ? from : j;
1072         j->generation = generation;
1073
1074         /* We assume that the the dependencies are bidirectional, and
1075          * hence can ignore UNIT_AFTER */
1076         SET_FOREACH(u, j->unit->dependencies[UNIT_BEFORE], i) {
1077                 Job *o;
1078
1079                 /* Is there a job for this unit? */
1080                 if (!(o = hashmap_get(m->transaction_jobs, u)))
1081
1082                         /* Ok, there is no job for this in the
1083                          * transaction, but maybe there is already one
1084                          * running? */
1085                         if (!(o = u->job))
1086                                 continue;
1087
1088                 if ((r = transaction_verify_order_one(m, o, j, generation, e)) < 0)
1089                         return r;
1090         }
1091
1092         /* Ok, let's backtrack, and remember that this entry is not on
1093          * our path anymore. */
1094         j->marker = NULL;
1095
1096         return 0;
1097 }
1098
1099 static int transaction_verify_order(Manager *m, unsigned *generation, DBusError *e) {
1100         Job *j;
1101         int r;
1102         Iterator i;
1103         unsigned g;
1104
1105         assert(m);
1106         assert(generation);
1107
1108         /* Check if the ordering graph is cyclic. If it is, try to fix
1109          * that up by dropping one of the jobs. */
1110
1111         g = (*generation)++;
1112
1113         HASHMAP_FOREACH(j, m->transaction_jobs, i)
1114                 if ((r = transaction_verify_order_one(m, j, NULL, g, e)) < 0)
1115                         return r;
1116
1117         return 0;
1118 }
1119
1120 static void transaction_collect_garbage(Manager *m) {
1121         bool again;
1122
1123         assert(m);
1124
1125         /* Drop jobs that are not required by any other job */
1126
1127         do {
1128                 Iterator i;
1129                 Job *j;
1130
1131                 again = false;
1132
1133                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1134                         if (j->object_list) {
1135                                 /* log_debug("Keeping job %s/%s because of %s/%s", */
1136                                 /*           j->unit->id, job_type_to_string(j->type), */
1137                                 /*           j->object_list->subject ? j->object_list->subject->unit->id : "root", */
1138                                 /*           j->object_list->subject ? job_type_to_string(j->object_list->subject->type) : "root"); */
1139                                 continue;
1140                         }
1141
1142                         /* log_debug("Garbage collecting job %s/%s", j->unit->id, job_type_to_string(j->type)); */
1143                         transaction_delete_job(m, j, true);
1144                         again = true;
1145                         break;
1146                 }
1147
1148         } while (again);
1149 }
1150
1151 static int transaction_is_destructive(Manager *m, DBusError *e) {
1152         Iterator i;
1153         Job *j;
1154
1155         assert(m);
1156
1157         /* Checks whether applying this transaction means that
1158          * existing jobs would be replaced */
1159
1160         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1161
1162                 /* Assume merged */
1163                 assert(!j->transaction_prev);
1164                 assert(!j->transaction_next);
1165
1166                 if (j->unit->job &&
1167                     j->unit->job != j &&
1168                     !job_type_is_superset(j->type, j->unit->job->type)) {
1169
1170                         dbus_set_error(e, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE, "Transaction is destructive.");
1171                         return -EEXIST;
1172                 }
1173         }
1174
1175         return 0;
1176 }
1177
1178 static void transaction_minimize_impact(Manager *m) {
1179         bool again;
1180         assert(m);
1181
1182         /* Drops all unnecessary jobs that reverse already active jobs
1183          * or that stop a running service. */
1184
1185         do {
1186                 Job *j;
1187                 Iterator i;
1188
1189                 again = false;
1190
1191                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1192                         LIST_FOREACH(transaction, j, j) {
1193                                 bool stops_running_service, changes_existing_job;
1194
1195                                 /* If it matters, we shouldn't drop it */
1196                                 if (j->matters_to_anchor)
1197                                         continue;
1198
1199                                 /* Would this stop a running service?
1200                                  * Would this change an existing job?
1201                                  * If so, let's drop this entry */
1202
1203                                 stops_running_service =
1204                                         j->type == JOB_STOP && UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(j->unit));
1205
1206                                 changes_existing_job =
1207                                         j->unit->job &&
1208                                         job_type_is_conflicting(j->type, j->unit->job->type);
1209
1210                                 if (!stops_running_service && !changes_existing_job)
1211                                         continue;
1212
1213                                 if (stops_running_service)
1214                                         log_debug("%s/%s would stop a running service.", j->unit->id, job_type_to_string(j->type));
1215
1216                                 if (changes_existing_job)
1217                                         log_debug("%s/%s would change existing job.", j->unit->id, job_type_to_string(j->type));
1218
1219                                 /* Ok, let's get rid of this */
1220                                 log_debug("Deleting %s/%s to minimize impact.", j->unit->id, job_type_to_string(j->type));
1221
1222                                 transaction_delete_job(m, j, true);
1223                                 again = true;
1224                                 break;
1225                         }
1226
1227                         if (again)
1228                                 break;
1229                 }
1230
1231         } while (again);
1232 }
1233
1234 static int transaction_apply(Manager *m, JobMode mode) {
1235         Iterator i;
1236         Job *j;
1237         int r;
1238
1239         /* Moves the transaction jobs to the set of active jobs */
1240
1241         if (mode == JOB_ISOLATE) {
1242
1243                 /* When isolating first kill all installed jobs which
1244                  * aren't part of the new transaction */
1245         rescan:
1246                 HASHMAP_FOREACH(j, m->jobs, i) {
1247                         assert(j->installed);
1248
1249                         if (hashmap_get(m->transaction_jobs, j->unit))
1250                                 continue;
1251
1252                         /* 'j' itself is safe to remove, but if other jobs
1253                            are invalidated recursively, our iterator may become
1254                            invalid and we need to start over. */
1255                         if (job_finish_and_invalidate(j, JOB_CANCELED) > 0)
1256                                 goto rescan;
1257                 }
1258         }
1259
1260         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1261                 /* Assume merged */
1262                 assert(!j->transaction_prev);
1263                 assert(!j->transaction_next);
1264
1265                 if (j->installed)
1266                         continue;
1267
1268                 if ((r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j)) < 0)
1269                         goto rollback;
1270         }
1271
1272         while ((j = hashmap_steal_first(m->transaction_jobs))) {
1273                 if (j->installed) {
1274                         /* log_debug("Skipping already installed job %s/%s as %u", j->unit->id, job_type_to_string(j->type), (unsigned) j->id); */
1275                         continue;
1276                 }
1277
1278                 if (j->unit->job)
1279                         job_free(j->unit->job);
1280
1281                 j->unit->job = j;
1282                 j->installed = true;
1283                 m->n_installed_jobs ++;
1284
1285                 /* We're fully installed. Now let's free data we don't
1286                  * need anymore. */
1287
1288                 assert(!j->transaction_next);
1289                 assert(!j->transaction_prev);
1290
1291                 job_add_to_run_queue(j);
1292                 job_add_to_dbus_queue(j);
1293                 job_start_timer(j);
1294
1295                 log_debug("Installed new job %s/%s as %u", j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
1296         }
1297
1298         /* As last step, kill all remaining job dependencies. */
1299         transaction_clean_dependencies(m);
1300
1301         return 0;
1302
1303 rollback:
1304
1305         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
1306                 if (j->installed)
1307                         continue;
1308
1309                 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
1310         }
1311
1312         return r;
1313 }
1314
1315 static int transaction_activate(Manager *m, JobMode mode, DBusError *e) {
1316         int r;
1317         unsigned generation = 1;
1318
1319         assert(m);
1320
1321         /* This applies the changes recorded in transaction_jobs to
1322          * the actual list of jobs, if possible. */
1323
1324         /* First step: figure out which jobs matter */
1325         transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++);
1326
1327         /* Second step: Try not to stop any running services if
1328          * we don't have to. Don't try to reverse running
1329          * jobs if we don't have to. */
1330         if (mode == JOB_FAIL)
1331                 transaction_minimize_impact(m);
1332
1333         /* Third step: Drop redundant jobs */
1334         transaction_drop_redundant(m);
1335
1336         for (;;) {
1337                 /* Fourth step: Let's remove unneeded jobs that might
1338                  * be lurking. */
1339                 if (mode != JOB_ISOLATE)
1340                         transaction_collect_garbage(m);
1341
1342                 /* Fifth step: verify order makes sense and correct
1343                  * cycles if necessary and possible */
1344                 if ((r = transaction_verify_order(m, &generation, e)) >= 0)
1345                         break;
1346
1347                 if (r != -EAGAIN) {
1348                         log_warning("Requested transaction contains an unfixable cyclic ordering dependency: %s", bus_error(e, r));
1349                         goto rollback;
1350                 }
1351
1352                 /* Let's see if the resulting transaction ordering
1353                  * graph is still cyclic... */
1354         }
1355
1356         for (;;) {
1357                 /* Sixth step: let's drop unmergeable entries if
1358                  * necessary and possible, merge entries we can
1359                  * merge */
1360                 if ((r = transaction_merge_jobs(m, e)) >= 0)
1361                         break;
1362
1363                 if (r != -EAGAIN) {
1364                         log_warning("Requested transaction contains unmergeable jobs: %s", bus_error(e, r));
1365                         goto rollback;
1366                 }
1367
1368                 /* Seventh step: an entry got dropped, let's garbage
1369                  * collect its dependencies. */
1370                 if (mode != JOB_ISOLATE)
1371                         transaction_collect_garbage(m);
1372
1373                 /* Let's see if the resulting transaction still has
1374                  * unmergeable entries ... */
1375         }
1376
1377         /* Eights step: Drop redundant jobs again, if the merging now allows us to drop more. */
1378         transaction_drop_redundant(m);
1379
1380         /* Ninth step: check whether we can actually apply this */
1381         if (mode == JOB_FAIL)
1382                 if ((r = transaction_is_destructive(m, e)) < 0) {
1383                         log_notice("Requested transaction contradicts existing jobs: %s", bus_error(e, r));
1384                         goto rollback;
1385                 }
1386
1387         /* Tenth step: apply changes */
1388         if ((r = transaction_apply(m, mode)) < 0) {
1389                 log_warning("Failed to apply transaction: %s", strerror(-r));
1390                 goto rollback;
1391         }
1392
1393         assert(hashmap_isempty(m->transaction_jobs));
1394         assert(!m->transaction_anchor);
1395
1396         return 0;
1397
1398 rollback:
1399         transaction_abort(m);
1400         return r;
1401 }
1402
1403 static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool override, bool *is_new) {
1404         Job *j, *f;
1405
1406         assert(m);
1407         assert(unit);
1408
1409         /* Looks for an existing prospective job and returns that. If
1410          * it doesn't exist it is created and added to the prospective
1411          * jobs list. */
1412
1413         f = hashmap_get(m->transaction_jobs, unit);
1414
1415         LIST_FOREACH(transaction, j, f) {
1416                 assert(j->unit == unit);
1417
1418                 if (j->type == type) {
1419                         if (is_new)
1420                                 *is_new = false;
1421                         return j;
1422                 }
1423         }
1424
1425         if (unit->job && unit->job->type == type)
1426                 j = unit->job;
1427         else if (!(j = job_new(m, type, unit)))
1428                 return NULL;
1429
1430         j->generation = 0;
1431         j->marker = NULL;
1432         j->matters_to_anchor = false;
1433         j->override = override;
1434
1435         LIST_PREPEND(Job, transaction, f, j);
1436
1437         if (hashmap_replace(m->transaction_jobs, unit, f) < 0) {
1438                 job_free(j);
1439                 return NULL;
1440         }
1441
1442         if (is_new)
1443                 *is_new = true;
1444
1445         /* log_debug("Added job %s/%s to transaction.", unit->id, job_type_to_string(type)); */
1446
1447         return j;
1448 }
1449
1450 void manager_transaction_unlink_job(Manager *m, Job *j, bool delete_dependencies) {
1451         assert(m);
1452         assert(j);
1453
1454         if (j->transaction_prev)
1455                 j->transaction_prev->transaction_next = j->transaction_next;
1456         else if (j->transaction_next)
1457                 hashmap_replace(m->transaction_jobs, j->unit, j->transaction_next);
1458         else
1459                 hashmap_remove_value(m->transaction_jobs, j->unit, j);
1460
1461         if (j->transaction_next)
1462                 j->transaction_next->transaction_prev = j->transaction_prev;
1463
1464         j->transaction_prev = j->transaction_next = NULL;
1465
1466         while (j->subject_list)
1467                 job_dependency_free(j->subject_list);
1468
1469         while (j->object_list) {
1470                 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
1471
1472                 job_dependency_free(j->object_list);
1473
1474                 if (other && delete_dependencies) {
1475                         log_debug("Deleting job %s/%s as dependency of job %s/%s",
1476                                   other->unit->id, job_type_to_string(other->type),
1477                                   j->unit->id, job_type_to_string(j->type));
1478                         transaction_delete_job(m, other, delete_dependencies);
1479                 }
1480         }
1481 }
1482
1483 static int transaction_add_job_and_dependencies(
1484                 Manager *m,
1485                 JobType type,
1486                 Unit *unit,
1487                 Job *by,
1488                 bool matters,
1489                 bool override,
1490                 bool conflicts,
1491                 bool ignore_requirements,
1492                 bool ignore_order,
1493                 DBusError *e,
1494                 Job **_ret) {
1495         Job *ret;
1496         Iterator i;
1497         Unit *dep;
1498         int r;
1499         bool is_new;
1500
1501         assert(m);
1502         assert(type < _JOB_TYPE_MAX);
1503         assert(unit);
1504
1505         /* log_debug("Pulling in %s/%s from %s/%s", */
1506         /*           unit->id, job_type_to_string(type), */
1507         /*           by ? by->unit->id : "NA", */
1508         /*           by ? job_type_to_string(by->type) : "NA"); */
1509
1510         if (unit->load_state != UNIT_LOADED &&
1511             unit->load_state != UNIT_ERROR &&
1512             unit->load_state != UNIT_MASKED) {
1513                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED, "Unit %s is not loaded properly.", unit->id);
1514                 return -EINVAL;
1515         }
1516
1517         if (type != JOB_STOP && unit->load_state == UNIT_ERROR) {
1518                 dbus_set_error(e, BUS_ERROR_LOAD_FAILED,
1519                                "Unit %s failed to load: %s. "
1520                                "See system logs and 'systemctl status %s' for details.",
1521                                unit->id,
1522                                strerror(-unit->load_error),
1523                                unit->id);
1524                 return -EINVAL;
1525         }
1526
1527         if (type != JOB_STOP && unit->load_state == UNIT_MASKED) {
1528                 dbus_set_error(e, BUS_ERROR_MASKED, "Unit %s is masked.", unit->id);
1529                 return -EINVAL;
1530         }
1531
1532         if (!unit_job_is_applicable(unit, type)) {
1533                 dbus_set_error(e, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE, "Job type %s is not applicable for unit %s.", job_type_to_string(type), unit->id);
1534                 return -EBADR;
1535         }
1536
1537         /* First add the job. */
1538         if (!(ret = transaction_add_one_job(m, type, unit, override, &is_new)))
1539                 return -ENOMEM;
1540
1541         ret->ignore_order = ret->ignore_order || ignore_order;
1542
1543         /* Then, add a link to the job. */
1544         if (!job_dependency_new(by, ret, matters, conflicts))
1545                 return -ENOMEM;
1546
1547         if (is_new && !ignore_requirements) {
1548                 Set *following;
1549
1550                 /* If we are following some other unit, make sure we
1551                  * add all dependencies of everybody following. */
1552                 if (unit_following_set(ret->unit, &following) > 0) {
1553                         SET_FOREACH(dep, following, i)
1554                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, false, override, false, false, ignore_order, e, NULL)) < 0) {
1555                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1556
1557                                         if (e)
1558                                                 dbus_error_free(e);
1559                                 }
1560
1561                         set_free(following);
1562                 }
1563
1564                 /* Finally, recursively add in all dependencies. */
1565                 if (type == JOB_START || type == JOB_RELOAD_OR_START) {
1566                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES], i)
1567                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1568                                         if (r != -EBADR)
1569                                                 goto fail;
1570
1571                                         if (e)
1572                                                 dbus_error_free(e);
1573                                 }
1574
1575                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BIND_TO], i)
1576                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1577
1578                                         if (r != -EBADR)
1579                                                 goto fail;
1580
1581                                         if (e)
1582                                                 dbus_error_free(e);
1583                                 }
1584
1585                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1586                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !override, override, false, false, ignore_order, e, NULL)) < 0) {
1587                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1588
1589                                         if (e)
1590                                                 dbus_error_free(e);
1591                                 }
1592
1593                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_WANTS], i)
1594                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, false, false, false, ignore_order, e, NULL)) < 0) {
1595                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1596
1597                                         if (e)
1598                                                 dbus_error_free(e);
1599                                 }
1600
1601                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE], i)
1602                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1603
1604                                         if (r != -EBADR)
1605                                                 goto fail;
1606
1607                                         if (e)
1608                                                 dbus_error_free(e);
1609                                 }
1610
1611                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1612                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !override, override, false, false, ignore_order, e, NULL)) < 0) {
1613                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1614
1615                                         if (e)
1616                                                 dbus_error_free(e);
1617                                 }
1618
1619                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTS], i)
1620                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, override, true, false, ignore_order, e, NULL)) < 0) {
1621
1622                                         if (r != -EBADR)
1623                                                 goto fail;
1624
1625                                         if (e)
1626                                                 dbus_error_free(e);
1627                                 }
1628
1629                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_CONFLICTED_BY], i)
1630                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, false, override, false, false, ignore_order, e, NULL)) < 0) {
1631                                         log_warning("Cannot add dependency job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1632
1633                                         if (e)
1634                                                 dbus_error_free(e);
1635                                 }
1636
1637                 }
1638
1639                 if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
1640
1641                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_REQUIRED_BY], i)
1642                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1643
1644                                         if (r != -EBADR)
1645                                                 goto fail;
1646
1647                                         if (e)
1648                                                 dbus_error_free(e);
1649                                 }
1650
1651                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_BOUND_BY], i)
1652                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, override, false, false, ignore_order, e, NULL)) < 0) {
1653
1654                                         if (r != -EBADR)
1655                                                 goto fail;
1656
1657                                         if (e)
1658                                                 dbus_error_free(e);
1659                                 }
1660                 }
1661
1662                 if (type == JOB_RELOAD || type == JOB_RELOAD_OR_START) {
1663
1664                         SET_FOREACH(dep, ret->unit->dependencies[UNIT_PROPAGATE_RELOAD_TO], i) {
1665                                 r = transaction_add_job_and_dependencies(m, JOB_RELOAD, dep, ret, false, override, false, false, ignore_order, e, NULL);
1666
1667                                 if (r < 0) {
1668                                         log_warning("Cannot add dependency reload job for unit %s, ignoring: %s", dep->id, bus_error(e, r));
1669
1670                                         if (e)
1671                                                 dbus_error_free(e);
1672                                 }
1673                         }
1674                 }
1675
1676                 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
1677         }
1678
1679         if (_ret)
1680                 *_ret = ret;
1681
1682         return 0;
1683
1684 fail:
1685         return r;
1686 }
1687
1688 static int transaction_add_isolate_jobs(Manager *m) {
1689         Iterator i;
1690         Unit *u;
1691         char *k;
1692         int r;
1693
1694         assert(m);
1695
1696         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1697
1698                 /* ignore aliases */
1699                 if (u->id != k)
1700                         continue;
1701
1702                 if (u->ignore_on_isolate)
1703                         continue;
1704
1705                 /* No need to stop inactive jobs */
1706                 if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(u)) && !u->job)
1707                         continue;
1708
1709                 /* Is there already something listed for this? */
1710                 if (hashmap_get(m->transaction_jobs, u))
1711                         continue;
1712
1713                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, u, NULL, true, false, false, false, false, NULL, NULL)) < 0)
1714                         log_warning("Cannot add isolate job for unit %s, ignoring: %s", u->id, strerror(-r));
1715         }
1716
1717         return 0;
1718 }
1719
1720 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
1721         int r;
1722         Job *ret;
1723
1724         assert(m);
1725         assert(type < _JOB_TYPE_MAX);
1726         assert(unit);
1727         assert(mode < _JOB_MODE_MAX);
1728
1729         if (mode == JOB_ISOLATE && type != JOB_START) {
1730                 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
1731                 return -EINVAL;
1732         }
1733
1734         if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1735                 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1736                 return -EPERM;
1737         }
1738
1739         log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1740
1741         if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, override, false,
1742                                                       mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1743                                                       mode == JOB_IGNORE_DEPENDENCIES, e, &ret)) < 0) {
1744                 transaction_abort(m);
1745                 return r;
1746         }
1747
1748         if (mode == JOB_ISOLATE)
1749                 if ((r = transaction_add_isolate_jobs(m)) < 0) {
1750                         transaction_abort(m);
1751                         return r;
1752                 }
1753
1754         if ((r = transaction_activate(m, mode, e)) < 0)
1755                 return r;
1756
1757         log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) ret->id);
1758
1759         if (_ret)
1760                 *_ret = ret;
1761
1762         return 0;
1763 }
1764
1765 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
1766         Unit *unit;
1767         int r;
1768
1769         assert(m);
1770         assert(type < _JOB_TYPE_MAX);
1771         assert(name);
1772         assert(mode < _JOB_MODE_MAX);
1773
1774         if ((r = manager_load_unit(m, name, NULL, NULL, &unit)) < 0)
1775                 return r;
1776
1777         return manager_add_job(m, type, unit, mode, override, e, _ret);
1778 }
1779
1780 Job *manager_get_job(Manager *m, uint32_t id) {
1781         assert(m);
1782
1783         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1784 }
1785
1786 Unit *manager_get_unit(Manager *m, const char *name) {
1787         assert(m);
1788         assert(name);
1789
1790         return hashmap_get(m->units, name);
1791 }
1792
1793 unsigned manager_dispatch_load_queue(Manager *m) {
1794         Unit *u;
1795         unsigned n = 0;
1796
1797         assert(m);
1798
1799         /* Make sure we are not run recursively */
1800         if (m->dispatching_load_queue)
1801                 return 0;
1802
1803         m->dispatching_load_queue = true;
1804
1805         /* Dispatches the load queue. Takes a unit from the queue and
1806          * tries to load its data until the queue is empty */
1807
1808         while ((u = m->load_queue)) {
1809                 assert(u->in_load_queue);
1810
1811                 unit_load(u);
1812                 n++;
1813         }
1814
1815         m->dispatching_load_queue = false;
1816         return n;
1817 }
1818
1819 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1820         Unit *ret;
1821         UnitType t;
1822         int r;
1823
1824         assert(m);
1825         assert(name || path);
1826
1827         /* This will prepare the unit for loading, but not actually
1828          * load anything from disk. */
1829
1830         if (path && !is_path(path)) {
1831                 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1832                 return -EINVAL;
1833         }
1834
1835         if (!name)
1836                 name = file_name_from_path(path);
1837
1838         t = unit_name_to_type(name);
1839
1840         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid_no_type(name, false)) {
1841                 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1842                 return -EINVAL;
1843         }
1844
1845         ret = manager_get_unit(m, name);
1846         if (ret) {
1847                 *_ret = ret;
1848                 return 1;
1849         }
1850
1851         ret = unit_new(m, unit_vtable[t]->object_size);
1852         if (!ret)
1853                 return -ENOMEM;
1854
1855         if (path) {
1856                 ret->fragment_path = strdup(path);
1857                 if (!ret->fragment_path) {
1858                         unit_free(ret);
1859                         return -ENOMEM;
1860                 }
1861         }
1862
1863         if ((r = unit_add_name(ret, name)) < 0) {
1864                 unit_free(ret);
1865                 return r;
1866         }
1867
1868         unit_add_to_load_queue(ret);
1869         unit_add_to_dbus_queue(ret);
1870         unit_add_to_gc_queue(ret);
1871
1872         if (_ret)
1873                 *_ret = ret;
1874
1875         return 0;
1876 }
1877
1878 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1879         int r;
1880
1881         assert(m);
1882
1883         /* This will load the service information files, but not actually
1884          * start any services or anything. */
1885
1886         if ((r = manager_load_unit_prepare(m, name, path, e, _ret)) != 0)
1887                 return r;
1888
1889         manager_dispatch_load_queue(m);
1890
1891         if (_ret)
1892                 *_ret = unit_follow_merge(*_ret);
1893
1894         return 0;
1895 }
1896
1897 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1898         Iterator i;
1899         Job *j;
1900
1901         assert(s);
1902         assert(f);
1903
1904         HASHMAP_FOREACH(j, s->jobs, i)
1905                 job_dump(j, f, prefix);
1906 }
1907
1908 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1909         Iterator i;
1910         Unit *u;
1911         const char *t;
1912
1913         assert(s);
1914         assert(f);
1915
1916         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1917                 if (u->id == t)
1918                         unit_dump(u, f, prefix);
1919 }
1920
1921 void manager_clear_jobs(Manager *m) {
1922         Job *j;
1923
1924         assert(m);
1925
1926         transaction_abort(m);
1927
1928         while ((j = hashmap_first(m->jobs)))
1929                 job_finish_and_invalidate(j, JOB_CANCELED);
1930 }
1931
1932 unsigned manager_dispatch_run_queue(Manager *m) {
1933         Job *j;
1934         unsigned n = 0;
1935
1936         if (m->dispatching_run_queue)
1937                 return 0;
1938
1939         m->dispatching_run_queue = true;
1940
1941         while ((j = m->run_queue)) {
1942                 assert(j->installed);
1943                 assert(j->in_run_queue);
1944
1945                 job_run_and_invalidate(j);
1946                 n++;
1947         }
1948
1949         m->dispatching_run_queue = false;
1950         return n;
1951 }
1952
1953 unsigned manager_dispatch_dbus_queue(Manager *m) {
1954         Job *j;
1955         Unit *u;
1956         unsigned n = 0;
1957
1958         assert(m);
1959
1960         if (m->dispatching_dbus_queue)
1961                 return 0;
1962
1963         m->dispatching_dbus_queue = true;
1964
1965         while ((u = m->dbus_unit_queue)) {
1966                 assert(u->in_dbus_queue);
1967
1968                 bus_unit_send_change_signal(u);
1969                 n++;
1970         }
1971
1972         while ((j = m->dbus_job_queue)) {
1973                 assert(j->in_dbus_queue);
1974
1975                 bus_job_send_change_signal(j);
1976                 n++;
1977         }
1978
1979         m->dispatching_dbus_queue = false;
1980         return n;
1981 }
1982
1983 static int manager_process_notify_fd(Manager *m) {
1984         ssize_t n;
1985
1986         assert(m);
1987
1988         for (;;) {
1989                 char buf[4096];
1990                 struct msghdr msghdr;
1991                 struct iovec iovec;
1992                 struct ucred *ucred;
1993                 union {
1994                         struct cmsghdr cmsghdr;
1995                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1996                 } control;
1997                 Unit *u;
1998                 char **tags;
1999
2000                 zero(iovec);
2001                 iovec.iov_base = buf;
2002                 iovec.iov_len = sizeof(buf)-1;
2003
2004                 zero(control);
2005                 zero(msghdr);
2006                 msghdr.msg_iov = &iovec;
2007                 msghdr.msg_iovlen = 1;
2008                 msghdr.msg_control = &control;
2009                 msghdr.msg_controllen = sizeof(control);
2010
2011                 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
2012                         if (n >= 0)
2013                                 return -EIO;
2014
2015                         if (errno == EAGAIN || errno == EINTR)
2016                                 break;
2017
2018                         return -errno;
2019                 }
2020
2021                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
2022                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
2023                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
2024                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
2025                         log_warning("Received notify message without credentials. Ignoring.");
2026                         continue;
2027                 }
2028
2029                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
2030
2031                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
2032                         if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
2033                                 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
2034                                 continue;
2035                         }
2036
2037                 assert((size_t) n < sizeof(buf));
2038                 buf[n] = 0;
2039                 if (!(tags = strv_split(buf, "\n\r")))
2040                         return -ENOMEM;
2041
2042                 log_debug("Got notification message for unit %s", u->id);
2043
2044                 if (UNIT_VTABLE(u)->notify_message)
2045                         UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
2046
2047                 strv_free(tags);
2048         }
2049
2050         return 0;
2051 }
2052
2053 static int manager_dispatch_sigchld(Manager *m) {
2054         assert(m);
2055
2056         for (;;) {
2057                 siginfo_t si;
2058                 Unit *u;
2059                 int r;
2060
2061                 zero(si);
2062
2063                 /* First we call waitd() for a PID and do not reap the
2064                  * zombie. That way we can still access /proc/$PID for
2065                  * it while it is a zombie. */
2066                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
2067
2068                         if (errno == ECHILD)
2069                                 break;
2070
2071                         if (errno == EINTR)
2072                                 continue;
2073
2074                         return -errno;
2075                 }
2076
2077                 if (si.si_pid <= 0)
2078                         break;
2079
2080                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
2081                         char *name = NULL;
2082
2083                         get_process_comm(si.si_pid, &name);
2084                         log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
2085                         free(name);
2086                 }
2087
2088                 /* Let's flush any message the dying child might still
2089                  * have queued for us. This ensures that the process
2090                  * still exists in /proc so that we can figure out
2091                  * which cgroup and hence unit it belongs to. */
2092                 if ((r = manager_process_notify_fd(m)) < 0)
2093                         return r;
2094
2095                 /* And now figure out the unit this belongs to */
2096                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
2097                         u = cgroup_unit_by_pid(m, si.si_pid);
2098
2099                 /* And now, we actually reap the zombie. */
2100                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
2101                         if (errno == EINTR)
2102                                 continue;
2103
2104                         return -errno;
2105                 }
2106
2107                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
2108                         continue;
2109
2110                 log_debug("Child %lu died (code=%s, status=%i/%s)",
2111                           (long unsigned) si.si_pid,
2112                           sigchld_code_to_string(si.si_code),
2113                           si.si_status,
2114                           strna(si.si_code == CLD_EXITED
2115                                 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
2116                                 : signal_to_string(si.si_status)));
2117
2118                 if (!u)
2119                         continue;
2120
2121                 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
2122
2123                 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
2124                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
2125         }
2126
2127         return 0;
2128 }
2129
2130 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
2131         int r;
2132         DBusError error;
2133
2134         dbus_error_init(&error);
2135
2136         log_debug("Activating special unit %s", name);
2137
2138         if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
2139                 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
2140
2141         dbus_error_free(&error);
2142
2143         return r;
2144 }
2145
2146 static int manager_process_signal_fd(Manager *m) {
2147         ssize_t n;
2148         struct signalfd_siginfo sfsi;
2149         bool sigchld = false;
2150
2151         assert(m);
2152
2153         for (;;) {
2154                 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
2155
2156                         if (n >= 0)
2157                                 return -EIO;
2158
2159                         if (errno == EINTR || errno == EAGAIN)
2160                                 break;
2161
2162                         return -errno;
2163                 }
2164
2165                 if (sfsi.ssi_pid > 0) {
2166                         char *p = NULL;
2167
2168                         get_process_comm(sfsi.ssi_pid, &p);
2169
2170                         log_debug("Received SIG%s from PID %lu (%s).",
2171                                   signal_to_string(sfsi.ssi_signo),
2172                                   (unsigned long) sfsi.ssi_pid, strna(p));
2173                         free(p);
2174                 } else
2175                         log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
2176
2177                 switch (sfsi.ssi_signo) {
2178
2179                 case SIGCHLD:
2180                         sigchld = true;
2181                         break;
2182
2183                 case SIGTERM:
2184                         if (m->running_as == MANAGER_SYSTEM) {
2185                                 /* This is for compatibility with the
2186                                  * original sysvinit */
2187                                 m->exit_code = MANAGER_REEXECUTE;
2188                                 break;
2189                         }
2190
2191                         /* Fall through */
2192
2193                 case SIGINT:
2194                         if (m->running_as == MANAGER_SYSTEM) {
2195                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
2196                                 break;
2197                         }
2198
2199                         /* Run the exit target if there is one, if not, just exit. */
2200                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
2201                                 m->exit_code = MANAGER_EXIT;
2202                                 return 0;
2203                         }
2204
2205                         break;
2206
2207                 case SIGWINCH:
2208                         if (m->running_as == MANAGER_SYSTEM)
2209                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
2210
2211                         /* This is a nop on non-init */
2212                         break;
2213
2214                 case SIGPWR:
2215                         if (m->running_as == MANAGER_SYSTEM)
2216                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
2217
2218                         /* This is a nop on non-init */
2219                         break;
2220
2221                 case SIGUSR1: {
2222                         Unit *u;
2223
2224                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
2225
2226                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
2227                                 log_info("Trying to reconnect to bus...");
2228                                 bus_init(m, true);
2229                         }
2230
2231                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
2232                                 log_info("Loading D-Bus service...");
2233                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
2234                         }
2235
2236                         break;
2237                 }
2238
2239                 case SIGUSR2: {
2240                         FILE *f;
2241                         char *dump = NULL;
2242                         size_t size;
2243
2244                         if (!(f = open_memstream(&dump, &size))) {
2245                                 log_warning("Failed to allocate memory stream.");
2246                                 break;
2247                         }
2248
2249                         manager_dump_units(m, f, "\t");
2250                         manager_dump_jobs(m, f, "\t");
2251
2252                         if (ferror(f)) {
2253                                 fclose(f);
2254                                 free(dump);
2255                                 log_warning("Failed to write status stream");
2256                                 break;
2257                         }
2258
2259                         fclose(f);
2260                         log_dump(LOG_INFO, dump);
2261                         free(dump);
2262
2263                         break;
2264                 }
2265
2266                 case SIGHUP:
2267                         m->exit_code = MANAGER_RELOAD;
2268                         break;
2269
2270                 default: {
2271
2272                         /* Starting SIGRTMIN+0 */
2273                         static const char * const target_table[] = {
2274                                 [0] = SPECIAL_DEFAULT_TARGET,
2275                                 [1] = SPECIAL_RESCUE_TARGET,
2276                                 [2] = SPECIAL_EMERGENCY_TARGET,
2277                                 [3] = SPECIAL_HALT_TARGET,
2278                                 [4] = SPECIAL_POWEROFF_TARGET,
2279                                 [5] = SPECIAL_REBOOT_TARGET,
2280                                 [6] = SPECIAL_KEXEC_TARGET
2281                         };
2282
2283                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
2284                         static const ManagerExitCode code_table[] = {
2285                                 [0] = MANAGER_HALT,
2286                                 [1] = MANAGER_POWEROFF,
2287                                 [2] = MANAGER_REBOOT,
2288                                 [3] = MANAGER_KEXEC
2289                         };
2290
2291                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
2292                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
2293                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
2294                                 manager_start_target(m, target_table[idx],
2295                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
2296                                 break;
2297                         }
2298
2299                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
2300                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
2301                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
2302                                 break;
2303                         }
2304
2305                         switch (sfsi.ssi_signo - SIGRTMIN) {
2306
2307                         case 20:
2308                                 log_debug("Enabling showing of status.");
2309                                 manager_set_show_status(m, true);
2310                                 break;
2311
2312                         case 21:
2313                                 log_debug("Disabling showing of status.");
2314                                 manager_set_show_status(m, false);
2315                                 break;
2316
2317                         case 22:
2318                                 log_set_max_level(LOG_DEBUG);
2319                                 log_notice("Setting log level to debug.");
2320                                 break;
2321
2322                         case 23:
2323                                 log_set_max_level(LOG_INFO);
2324                                 log_notice("Setting log level to info.");
2325                                 break;
2326
2327                         case 26:
2328                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
2329                                 log_notice("Setting log target to journal-or-kmsg.");
2330                                 break;
2331
2332                         case 27:
2333                                 log_set_target(LOG_TARGET_CONSOLE);
2334                                 log_notice("Setting log target to console.");
2335                                 break;
2336
2337                         case 28:
2338                                 log_set_target(LOG_TARGET_KMSG);
2339                                 log_notice("Setting log target to kmsg.");
2340                                 break;
2341
2342                         case 29:
2343                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
2344                                 log_notice("Setting log target to syslog-or-kmsg.");
2345                                 break;
2346
2347                         default:
2348                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
2349                         }
2350                 }
2351                 }
2352         }
2353
2354         if (sigchld)
2355                 return manager_dispatch_sigchld(m);
2356
2357         return 0;
2358 }
2359
2360 static int process_event(Manager *m, struct epoll_event *ev) {
2361         int r;
2362         Watch *w;
2363
2364         assert(m);
2365         assert(ev);
2366
2367         assert_se(w = ev->data.ptr);
2368
2369         if (w->type == WATCH_INVALID)
2370                 return 0;
2371
2372         switch (w->type) {
2373
2374         case WATCH_SIGNAL:
2375
2376                 /* An incoming signal? */
2377                 if (ev->events != EPOLLIN)
2378                         return -EINVAL;
2379
2380                 if ((r = manager_process_signal_fd(m)) < 0)
2381                         return r;
2382
2383                 break;
2384
2385         case WATCH_NOTIFY:
2386
2387                 /* An incoming daemon notification event? */
2388                 if (ev->events != EPOLLIN)
2389                         return -EINVAL;
2390
2391                 if ((r = manager_process_notify_fd(m)) < 0)
2392                         return r;
2393
2394                 break;
2395
2396         case WATCH_FD:
2397
2398                 /* Some fd event, to be dispatched to the units */
2399                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
2400                 break;
2401
2402         case WATCH_UNIT_TIMER:
2403         case WATCH_JOB_TIMER: {
2404                 uint64_t v;
2405                 ssize_t k;
2406
2407                 /* Some timer event, to be dispatched to the units */
2408                 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
2409
2410                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
2411                                 break;
2412
2413                         return k < 0 ? -errno : -EIO;
2414                 }
2415
2416                 if (w->type == WATCH_UNIT_TIMER)
2417                         UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
2418                 else
2419                         job_timer_event(w->data.job, v, w);
2420                 break;
2421         }
2422
2423         case WATCH_MOUNT:
2424                 /* Some mount table change, intended for the mount subsystem */
2425                 mount_fd_event(m, ev->events);
2426                 break;
2427
2428         case WATCH_SWAP:
2429                 /* Some swap table change, intended for the swap subsystem */
2430                 swap_fd_event(m, ev->events);
2431                 break;
2432
2433         case WATCH_UDEV:
2434                 /* Some notification from udev, intended for the device subsystem */
2435                 device_fd_event(m, ev->events);
2436                 break;
2437
2438         case WATCH_DBUS_WATCH:
2439                 bus_watch_event(m, w, ev->events);
2440                 break;
2441
2442         case WATCH_DBUS_TIMEOUT:
2443                 bus_timeout_event(m, w, ev->events);
2444                 break;
2445
2446         default:
2447                 log_error("event type=%i", w->type);
2448                 assert_not_reached("Unknown epoll event type.");
2449         }
2450
2451         return 0;
2452 }
2453
2454 int manager_loop(Manager *m) {
2455         int r;
2456         int wait_msec = -1;
2457
2458         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
2459
2460         assert(m);
2461         m->exit_code = MANAGER_RUNNING;
2462
2463         /* Release the path cache */
2464         set_free_free(m->unit_path_cache);
2465         m->unit_path_cache = NULL;
2466
2467         manager_check_finished(m);
2468
2469         /* There might still be some zombies hanging around from
2470          * before we were exec()'ed. Leat's reap them */
2471         r = manager_dispatch_sigchld(m);
2472         if (r < 0)
2473                 return r;
2474
2475         /* Sleep for half the watchdog time */
2476         if (m->runtime_watchdog > 0 && m->running_as == MANAGER_SYSTEM)  {
2477                 wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
2478                 if (wait_msec <= 0)
2479                         wait_msec = 1;
2480         }
2481
2482         while (m->exit_code == MANAGER_RUNNING) {
2483                 struct epoll_event event;
2484                 int n;
2485
2486                 if (wait_msec >= 0)
2487                         watchdog_ping();
2488
2489                 if (!ratelimit_test(&rl)) {
2490                         /* Yay, something is going seriously wrong, pause a little */
2491                         log_warning("Looping too fast. Throttling execution a little.");
2492                         sleep(1);
2493                         continue;
2494                 }
2495
2496                 if (manager_dispatch_load_queue(m) > 0)
2497                         continue;
2498
2499                 if (manager_dispatch_run_queue(m) > 0)
2500                         continue;
2501
2502                 if (bus_dispatch(m) > 0)
2503                         continue;
2504
2505                 if (manager_dispatch_cleanup_queue(m) > 0)
2506                         continue;
2507
2508                 if (manager_dispatch_gc_queue(m) > 0)
2509                         continue;
2510
2511                 if (manager_dispatch_dbus_queue(m) > 0)
2512                         continue;
2513
2514                 if (swap_dispatch_reload(m) > 0)
2515                         continue;
2516
2517                 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
2518                 if (n < 0) {
2519
2520                         if (errno == EINTR)
2521                                 continue;
2522
2523                         return -errno;
2524                 } else if (n == 0)
2525                         continue;
2526
2527                 assert(n == 1);
2528
2529                 r = process_event(m, &event);
2530                 if (r < 0)
2531                         return r;
2532         }
2533
2534         return m->exit_code;
2535 }
2536
2537 int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
2538         char *n;
2539         Unit *u;
2540
2541         assert(m);
2542         assert(s);
2543         assert(_u);
2544
2545         if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
2546                 return -EINVAL;
2547
2548         if (!(n = bus_path_unescape(s+31)))
2549                 return -ENOMEM;
2550
2551         u = manager_get_unit(m, n);
2552         free(n);
2553
2554         if (!u)
2555                 return -ENOENT;
2556
2557         *_u = u;
2558
2559         return 0;
2560 }
2561
2562 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2563         Job *j;
2564         unsigned id;
2565         int r;
2566
2567         assert(m);
2568         assert(s);
2569         assert(_j);
2570
2571         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
2572                 return -EINVAL;
2573
2574         if ((r = safe_atou(s + 30, &id)) < 0)
2575                 return r;
2576
2577         if (!(j = manager_get_job(m, id)))
2578                 return -ENOENT;
2579
2580         *_j = j;
2581
2582         return 0;
2583 }
2584
2585 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2586
2587 #ifdef HAVE_AUDIT
2588         char *p;
2589
2590         if (m->audit_fd < 0)
2591                 return;
2592
2593         /* Don't generate audit events if the service was already
2594          * started and we're just deserializing */
2595         if (m->n_reloading > 0)
2596                 return;
2597
2598         if (m->running_as != MANAGER_SYSTEM)
2599                 return;
2600
2601         if (u->type != UNIT_SERVICE)
2602                 return;
2603
2604         if (!(p = unit_name_to_prefix_and_instance(u->id))) {
2605                 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
2606                 return;
2607         }
2608
2609         if (audit_log_user_comm_message(m->audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
2610                 log_warning("Failed to send audit message: %m");
2611
2612                 if (errno == EPERM) {
2613                         /* We aren't allowed to send audit messages?
2614                          * Then let's not retry again, to avoid
2615                          * spamming the user with the same and same
2616                          * messages over and over. */
2617
2618                         audit_close(m->audit_fd);
2619                         m->audit_fd = -1;
2620                 }
2621         }
2622
2623         free(p);
2624 #endif
2625
2626 }
2627
2628 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2629         int fd = -1;
2630         union sockaddr_union sa;
2631         int n = 0;
2632         char *message = NULL;
2633
2634         /* Don't generate plymouth events if the service was already
2635          * started and we're just deserializing */
2636         if (m->n_reloading > 0)
2637                 return;
2638
2639         if (m->running_as != MANAGER_SYSTEM)
2640                 return;
2641
2642         if (u->type != UNIT_SERVICE &&
2643             u->type != UNIT_MOUNT &&
2644             u->type != UNIT_SWAP)
2645                 return;
2646
2647         /* We set SOCK_NONBLOCK here so that we rather drop the
2648          * message then wait for plymouth */
2649         if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
2650                 log_error("socket() failed: %m");
2651                 return;
2652         }
2653
2654         zero(sa);
2655         sa.sa.sa_family = AF_UNIX;
2656         strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
2657         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2658
2659                 if (errno != EPIPE &&
2660                     errno != EAGAIN &&
2661                     errno != ENOENT &&
2662                     errno != ECONNREFUSED &&
2663                     errno != ECONNRESET &&
2664                     errno != ECONNABORTED)
2665                         log_error("connect() failed: %m");
2666
2667                 goto finish;
2668         }
2669
2670         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2671                 log_error("Out of memory");
2672                 goto finish;
2673         }
2674
2675         errno = 0;
2676         if (write(fd, message, n + 1) != n + 1) {
2677
2678                 if (errno != EPIPE &&
2679                     errno != EAGAIN &&
2680                     errno != ENOENT &&
2681                     errno != ECONNREFUSED &&
2682                     errno != ECONNRESET &&
2683                     errno != ECONNABORTED)
2684                         log_error("Failed to write Plymouth message: %m");
2685
2686                 goto finish;
2687         }
2688
2689 finish:
2690         if (fd >= 0)
2691                 close_nointr_nofail(fd);
2692
2693         free(message);
2694 }
2695
2696 void manager_dispatch_bus_name_owner_changed(
2697                 Manager *m,
2698                 const char *name,
2699                 const char* old_owner,
2700                 const char *new_owner) {
2701
2702         Unit *u;
2703
2704         assert(m);
2705         assert(name);
2706
2707         if (!(u = hashmap_get(m->watch_bus, name)))
2708                 return;
2709
2710         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2711 }
2712
2713 void manager_dispatch_bus_query_pid_done(
2714                 Manager *m,
2715                 const char *name,
2716                 pid_t pid) {
2717
2718         Unit *u;
2719
2720         assert(m);
2721         assert(name);
2722         assert(pid >= 1);
2723
2724         if (!(u = hashmap_get(m->watch_bus, name)))
2725                 return;
2726
2727         UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
2728 }
2729
2730 int manager_open_serialization(Manager *m, FILE **_f) {
2731         char *path = NULL;
2732         mode_t saved_umask;
2733         int fd;
2734         FILE *f;
2735
2736         assert(_f);
2737
2738         if (m->running_as == MANAGER_SYSTEM)
2739                 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
2740         else
2741                 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
2742
2743         if (!path)
2744                 return -ENOMEM;
2745
2746         saved_umask = umask(0077);
2747         fd = mkostemp(path, O_RDWR|O_CLOEXEC);
2748         umask(saved_umask);
2749
2750         if (fd < 0) {
2751                 free(path);
2752                 return -errno;
2753         }
2754
2755         unlink(path);
2756
2757         log_debug("Serializing state to %s", path);
2758         free(path);
2759
2760         if (!(f = fdopen(fd, "w+")))
2761                 return -errno;
2762
2763         *_f = f;
2764
2765         return 0;
2766 }
2767
2768 int manager_serialize(Manager *m, FILE *f, FDSet *fds) {
2769         Iterator i;
2770         Unit *u;
2771         const char *t;
2772         int r;
2773
2774         assert(m);
2775         assert(f);
2776         assert(fds);
2777
2778         m->n_reloading ++;
2779
2780         fprintf(f, "current-job-id=%i\n", m->current_job_id);
2781         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2782
2783         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2784         dual_timestamp_serialize(f, "startup-timestamp", &m->startup_timestamp);
2785         dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2786
2787         fputc('\n', f);
2788
2789         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2790                 if (u->id != t)
2791                         continue;
2792
2793                 if (!unit_can_serialize(u))
2794                         continue;
2795
2796                 /* Start marker */
2797                 fputs(u->id, f);
2798                 fputc('\n', f);
2799
2800                 if ((r = unit_serialize(u, f, fds)) < 0) {
2801                         m->n_reloading --;
2802                         return r;
2803                 }
2804         }
2805
2806         assert(m->n_reloading > 0);
2807         m->n_reloading --;
2808
2809         if (ferror(f))
2810                 return -EIO;
2811
2812         r = bus_fdset_add_all(m, fds);
2813         if (r < 0)
2814                 return r;
2815
2816         return 0;
2817 }
2818
2819 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2820         int r = 0;
2821
2822         assert(m);
2823         assert(f);
2824
2825         log_debug("Deserializing state...");
2826
2827         m->n_reloading ++;
2828
2829         for (;;) {
2830                 char line[LINE_MAX], *l;
2831
2832                 if (!fgets(line, sizeof(line), f)) {
2833                         if (feof(f))
2834                                 r = 0;
2835                         else
2836                                 r = -errno;
2837
2838                         goto finish;
2839                 }
2840
2841                 char_array_0(line);
2842                 l = strstrip(line);
2843
2844                 if (l[0] == 0)
2845                         break;
2846
2847                 if (startswith(l, "current-job-id=")) {
2848                         uint32_t id;
2849
2850                         if (safe_atou32(l+15, &id) < 0)
2851                                 log_debug("Failed to parse current job id value %s", l+15);
2852                         else
2853                                 m->current_job_id = MAX(m->current_job_id, id);
2854                 } else if (startswith(l, "taint-usr=")) {
2855                         int b;
2856
2857                         if ((b = parse_boolean(l+10)) < 0)
2858                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2859                         else
2860                                 m->taint_usr = m->taint_usr || b;
2861                 } else if (startswith(l, "initrd-timestamp="))
2862                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2863                 else if (startswith(l, "startup-timestamp="))
2864                         dual_timestamp_deserialize(l+18, &m->startup_timestamp);
2865                 else if (startswith(l, "finish-timestamp="))
2866                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2867                 else
2868                         log_debug("Unknown serialization item '%s'", l);
2869         }
2870
2871         for (;;) {
2872                 Unit *u;
2873                 char name[UNIT_NAME_MAX+2];
2874
2875                 /* Start marker */
2876                 if (!fgets(name, sizeof(name), f)) {
2877                         if (feof(f))
2878                                 r = 0;
2879                         else
2880                                 r = -errno;
2881
2882                         goto finish;
2883                 }
2884
2885                 char_array_0(name);
2886
2887                 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
2888                         goto finish;
2889
2890                 if ((r = unit_deserialize(u, f, fds)) < 0)
2891                         goto finish;
2892         }
2893
2894 finish:
2895         if (ferror(f)) {
2896                 r = -EIO;
2897                 goto finish;
2898         }
2899
2900         assert(m->n_reloading > 0);
2901         m->n_reloading --;
2902
2903         return r;
2904 }
2905
2906 int manager_reload(Manager *m) {
2907         int r, q;
2908         FILE *f;
2909         FDSet *fds;
2910
2911         assert(m);
2912
2913         if ((r = manager_open_serialization(m, &f)) < 0)
2914                 return r;
2915
2916         m->n_reloading ++;
2917
2918         if (!(fds = fdset_new())) {
2919                 m->n_reloading --;
2920                 r = -ENOMEM;
2921                 goto finish;
2922         }
2923
2924         if ((r = manager_serialize(m, f, fds)) < 0) {
2925                 m->n_reloading --;
2926                 goto finish;
2927         }
2928
2929         if (fseeko(f, 0, SEEK_SET) < 0) {
2930                 m->n_reloading --;
2931                 r = -errno;
2932                 goto finish;
2933         }
2934
2935         /* From here on there is no way back. */
2936         manager_clear_jobs_and_units(m);
2937         manager_undo_generators(m);
2938
2939         /* Find new unit paths */
2940         lookup_paths_free(&m->lookup_paths);
2941         if ((q = lookup_paths_init(&m->lookup_paths, m->running_as, true)) < 0)
2942                 r = q;
2943
2944         manager_run_generators(m);
2945
2946         manager_build_unit_path_cache(m);
2947
2948         /* First, enumerate what we can from all config files */
2949         if ((q = manager_enumerate(m)) < 0)
2950                 r = q;
2951
2952         /* Second, deserialize our stored data */
2953         if ((q = manager_deserialize(m, f, fds)) < 0)
2954                 r = q;
2955
2956         fclose(f);
2957         f = NULL;
2958
2959         /* Third, fire things up! */
2960         if ((q = manager_coldplug(m)) < 0)
2961                 r = q;
2962
2963         assert(m->n_reloading > 0);
2964         m->n_reloading--;
2965
2966 finish:
2967         if (f)
2968                 fclose(f);
2969
2970         if (fds)
2971                 fdset_free(fds);
2972
2973         return r;
2974 }
2975
2976 bool manager_is_booting_or_shutting_down(Manager *m) {
2977         Unit *u;
2978
2979         assert(m);
2980
2981         /* Is the initial job still around? */
2982         if (manager_get_job(m, m->default_unit_job_id))
2983                 return true;
2984
2985         /* Is there a job for the shutdown target? */
2986         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2987         if (u)
2988                 return !!u->job;
2989
2990         return false;
2991 }
2992
2993 void manager_reset_failed(Manager *m) {
2994         Unit *u;
2995         Iterator i;
2996
2997         assert(m);
2998
2999         HASHMAP_FOREACH(u, m->units, i)
3000                 unit_reset_failed(u);
3001 }
3002
3003 bool manager_unit_pending_inactive(Manager *m, const char *name) {
3004         Unit *u;
3005
3006         assert(m);
3007         assert(name);
3008
3009         /* Returns true if the unit is inactive or going down */
3010         if (!(u = manager_get_unit(m, name)))
3011                 return true;
3012
3013         return unit_pending_inactive(u);
3014 }
3015
3016 void manager_check_finished(Manager *m) {
3017         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
3018         usec_t kernel_usec, initrd_usec, userspace_usec, total_usec;
3019
3020         assert(m);
3021
3022         if (dual_timestamp_is_set(&m->finish_timestamp))
3023                 return;
3024
3025         if (hashmap_size(m->jobs) > 0)
3026                 return;
3027
3028         dual_timestamp_get(&m->finish_timestamp);
3029
3030         if (m->running_as == MANAGER_SYSTEM && detect_container(NULL) <= 0) {
3031
3032                 userspace_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
3033                 total_usec = m->finish_timestamp.monotonic;
3034
3035                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
3036
3037                         kernel_usec = m->initrd_timestamp.monotonic;
3038                         initrd_usec = m->startup_timestamp.monotonic - m->initrd_timestamp.monotonic;
3039
3040                         log_info("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
3041                                  format_timespan(kernel, sizeof(kernel), kernel_usec),
3042                                  format_timespan(initrd, sizeof(initrd), initrd_usec),
3043                                  format_timespan(userspace, sizeof(userspace), userspace_usec),
3044                                  format_timespan(sum, sizeof(sum), total_usec));
3045                 } else {
3046                         kernel_usec = m->startup_timestamp.monotonic;
3047                         initrd_usec = 0;
3048
3049                         log_info("Startup finished in %s (kernel) + %s (userspace) = %s.",
3050                                  format_timespan(kernel, sizeof(kernel), kernel_usec),
3051                                  format_timespan(userspace, sizeof(userspace), userspace_usec),
3052                                  format_timespan(sum, sizeof(sum), total_usec));
3053                 }
3054         } else {
3055                 userspace_usec = initrd_usec = kernel_usec = 0;
3056                 total_usec = m->finish_timestamp.monotonic - m->startup_timestamp.monotonic;
3057
3058                 log_debug("Startup finished in %s.",
3059                           format_timespan(sum, sizeof(sum), total_usec));
3060         }
3061
3062         bus_broadcast_finished(m, kernel_usec, initrd_usec, userspace_usec, total_usec);
3063
3064         sd_notifyf(false,
3065                    "READY=1\nSTATUS=Startup finished in %s.",
3066                    format_timespan(sum, sizeof(sum), total_usec));
3067 }
3068
3069 void manager_run_generators(Manager *m) {
3070         DIR *d = NULL;
3071         const char *generator_path;
3072         const char *argv[3];
3073         mode_t u;
3074
3075         assert(m);
3076
3077         generator_path = m->running_as == MANAGER_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
3078         if (!(d = opendir(generator_path))) {
3079
3080                 if (errno == ENOENT)
3081                         return;
3082
3083                 log_error("Failed to enumerate generator directory: %m");
3084                 return;
3085         }
3086
3087         if (!m->generator_unit_path) {
3088                 const char *p;
3089                 char user_path[] = "/tmp/systemd-generator-XXXXXX";
3090
3091                 if (m->running_as == MANAGER_SYSTEM && getpid() == 1) {
3092                         p = "/run/systemd/generator";
3093
3094                         if (mkdir_p(p, 0755) < 0) {
3095                                 log_error("Failed to create generator directory: %m");
3096                                 goto finish;
3097                         }
3098
3099                 } else {
3100                         if (!(p = mkdtemp(user_path))) {
3101                                 log_error("Failed to create generator directory: %m");
3102                                 goto finish;
3103                         }
3104                 }
3105
3106                 if (!(m->generator_unit_path = strdup(p))) {
3107                         log_error("Failed to allocate generator unit path.");
3108                         goto finish;
3109                 }
3110         }
3111
3112         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
3113         argv[1] = m->generator_unit_path;
3114         argv[2] = NULL;
3115
3116         u = umask(0022);
3117         execute_directory(generator_path, d, (char**) argv);
3118         umask(u);
3119
3120         if (rmdir(m->generator_unit_path) >= 0) {
3121                 /* Uh? we were able to remove this dir? I guess that
3122                  * means the directory was empty, hence let's shortcut
3123                  * this */
3124
3125                 free(m->generator_unit_path);
3126                 m->generator_unit_path = NULL;
3127                 goto finish;
3128         }
3129
3130         if (!strv_find(m->lookup_paths.unit_path, m->generator_unit_path)) {
3131                 char **l;
3132
3133                 if (!(l = strv_append(m->lookup_paths.unit_path, m->generator_unit_path))) {
3134                         log_error("Failed to add generator directory to unit search path: %m");
3135                         goto finish;
3136                 }
3137
3138                 strv_free(m->lookup_paths.unit_path);
3139                 m->lookup_paths.unit_path = l;
3140
3141                 log_debug("Added generator unit path %s to search path.", m->generator_unit_path);
3142         }
3143
3144 finish:
3145         if (d)
3146                 closedir(d);
3147 }
3148
3149 void manager_undo_generators(Manager *m) {
3150         assert(m);
3151
3152         if (!m->generator_unit_path)
3153                 return;
3154
3155         strv_remove(m->lookup_paths.unit_path, m->generator_unit_path);
3156         rm_rf(m->generator_unit_path, false, true, false);
3157
3158         free(m->generator_unit_path);
3159         m->generator_unit_path = NULL;
3160 }
3161
3162 int manager_set_default_controllers(Manager *m, char **controllers) {
3163         char **l;
3164
3165         assert(m);
3166
3167         if (!(l = strv_copy(controllers)))
3168                 return -ENOMEM;
3169
3170         strv_free(m->default_controllers);
3171         m->default_controllers = l;
3172
3173         return 0;
3174 }
3175
3176 void manager_recheck_journal(Manager *m) {
3177         Unit *u;
3178
3179         assert(m);
3180
3181         if (m->running_as != MANAGER_SYSTEM)
3182                 return;
3183
3184         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
3185         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
3186                 log_close_journal();
3187                 return;
3188         }
3189
3190         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
3191         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
3192                 log_close_journal();
3193                 return;
3194         }
3195
3196         /* Hmm, OK, so the socket is fully up and the service is up
3197          * too, then let's make use of the thing. */
3198         log_open();
3199 }
3200
3201 void manager_set_show_status(Manager *m, bool b) {
3202         assert(m);
3203
3204         if (m->running_as != MANAGER_SYSTEM)
3205                 return;
3206
3207         m->show_status = b;
3208
3209         if (b)
3210                 touch("/run/systemd/show-status");
3211         else
3212                 unlink("/run/systemd/show-status");
3213 }
3214
3215 bool manager_get_show_status(Manager *m) {
3216         assert(m);
3217
3218         if (m->running_as != MANAGER_SYSTEM)
3219                 return false;
3220
3221         if (m->show_status)
3222                 return true;
3223
3224         /* If Plymouth is running make sure we show the status, so
3225          * that there's something nice to see when people press Esc */
3226
3227         return plymouth_running();
3228 }
3229
3230 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
3231         [MANAGER_SYSTEM] = "system",
3232         [MANAGER_USER] = "user"
3233 };
3234
3235 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);