]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/manager.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
relicense to LGPLv2.1 (with exceptions)
[thirdparty/systemd.git] / src / core / manager.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <assert.h>
23 #include <errno.h>
24 #include <string.h>
25 #include <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 = 0, initrd_usec = 0, userspace_usec = 0, total_usec = 0;
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);
Unnamed repository; edit this file 'description' to name the repository.