1
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4
This file is part of systemd.
6
Copyright 2010 Lennart Poettering
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.
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.
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/>.
25
#include <sys/epoll.h>
27
#include <sys/signalfd.h>
31
#include <sys/reboot.h>
32
#include <sys/ioctl.h>
36
#include <sys/types.h>
39
#include <sys/timerfd.h>
45
#include "systemd/sd-daemon.h"
46
#include "systemd/sd-id128.h"
47
#include "systemd/sd-messages.h"
50
#include "transaction.h"
57
#include "ratelimit.h"
59
#include "mount-setup.h"
60
#include "unit-name.h"
61
#include "dbus-unit.h"
64
#include "path-lookup.h"
66
#include "bus-errors.h"
67
#include "exit-status.h"
70
#include "cgroup-util.h"
71
#include "path-util.h"
75
/* As soon as 16 units are in our GC queue, make sure to run a gc sweep */
76
#define GC_QUEUE_ENTRIES_MAX 16
78
/* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
79
#define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
81
/* Initial delay and the interval for printing status messages about running jobs */
82
#define JOBS_IN_PROGRESS_WAIT_SEC 5
83
#define JOBS_IN_PROGRESS_PERIOD_SEC 1
84
#define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
86
/* Where clients shall send notification messages to */
87
#define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
89
#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
91
static int manager_setup_notify(Manager *m) {
94
struct sockaddr_un un;
96
.sa.sa_family = AF_UNIX,
98
struct epoll_event ev = {
100
.data.ptr = &m->notify_watch,
104
m->notify_watch.type = WATCH_NOTIFY;
105
m->notify_watch.fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
106
if (m->notify_watch.fd < 0) {
107
log_error("Failed to allocate notification socket: %m");
111
if (getpid() != 1 || detect_container(NULL) > 0)
112
snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%llu", random_ull());
114
strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
116
sa.un.sun_path[0] = 0;
118
r = bind(m->notify_watch.fd, &sa.sa,
119
offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
121
log_error("bind() failed: %m");
125
r = setsockopt(m->notify_watch.fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
127
log_error("SO_PASSCRED failed: %m");
131
r = epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->notify_watch.fd, &ev);
133
log_error("Failed to add notification socket fd to epoll: %m");
137
sa.un.sun_path[0] = '@';
138
m->notify_socket = strdup(sa.un.sun_path);
139
if (!m->notify_socket)
142
log_debug("Using notification socket %s", m->notify_socket);
147
static int manager_jobs_in_progress_mod_timer(Manager *m) {
148
struct itimerspec its = {
149
.it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC,
150
.it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC,
153
if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
156
if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
162
static int manager_watch_jobs_in_progress(Manager *m) {
163
struct epoll_event ev = {
165
.data.ptr = &m->jobs_in_progress_watch,
169
if (m->jobs_in_progress_watch.type != WATCH_INVALID)
172
m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
173
m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
174
if (m->jobs_in_progress_watch.fd < 0) {
175
log_error("Failed to create timerfd: %m");
180
r = manager_jobs_in_progress_mod_timer(m);
182
log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
186
if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
187
log_error("Failed to add jobs progress timer fd to epoll: %m");
192
log_debug("Set up jobs progress timerfd.");
197
if (m->jobs_in_progress_watch.fd >= 0)
198
close_nointr_nofail(m->jobs_in_progress_watch.fd);
199
watch_init(&m->jobs_in_progress_watch);
203
static void manager_unwatch_jobs_in_progress(Manager *m) {
204
if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
207
assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
208
close_nointr_nofail(m->jobs_in_progress_watch.fd);
209
watch_init(&m->jobs_in_progress_watch);
210
m->jobs_in_progress_iteration = 0;
212
log_debug("Closed jobs progress timerfd.");
215
#define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
216
static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
219
assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
220
assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
224
p = mempset(p, ' ', pos-2);
225
p = stpcpy(p, ANSI_RED_ON);
229
if (pos > 0 && pos <= width) {
230
p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
234
p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
237
p = stpcpy(p, ANSI_RED_ON);
240
p = mempset(p, ' ', width-1-pos);
241
p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
245
static void manager_print_jobs_in_progress(Manager *m) {
248
char *job_of_n = NULL;
249
unsigned counter = 0, print_nr;
250
char cylon[6 + CYLON_BUFFER_EXTRA + 1];
253
print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
255
HASHMAP_FOREACH(j, m->jobs, i)
256
if (j->state == JOB_RUNNING && counter++ == print_nr)
259
/* m->n_running_jobs must be consistent with the contents of m->jobs,
260
* so the above loop must have succeeded in finding j. */
261
assert(counter == print_nr + 1);
263
cylon_pos = m->jobs_in_progress_iteration % 14;
265
cylon_pos = 14 - cylon_pos;
266
draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
268
if (m->n_running_jobs > 1)
269
if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
272
manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
273
strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
276
m->jobs_in_progress_iteration++;
279
static int manager_setup_time_change(Manager *m) {
280
struct epoll_event ev = {
282
.data.ptr = &m->time_change_watch,
285
/* We only care for the cancellation event, hence we set the
286
* timeout to the latest possible value. */
287
struct itimerspec its = {
288
.it_value.tv_sec = TIME_T_MAX,
290
assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
292
assert(m->time_change_watch.type == WATCH_INVALID);
294
/* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
295
* CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
297
m->time_change_watch.type = WATCH_TIME_CHANGE;
298
m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
299
if (m->time_change_watch.fd < 0) {
300
log_error("Failed to create timerfd: %m");
304
if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
305
log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
306
close_nointr_nofail(m->time_change_watch.fd);
307
watch_init(&m->time_change_watch);
311
if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
312
log_error("Failed to add timer change fd to epoll: %m");
316
log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
321
static int enable_special_signals(Manager *m) {
326
/* Enable that we get SIGINT on control-alt-del. In containers
327
* this will fail with EPERM (older) or EINVAL (newer), so
329
if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
330
log_warning("Failed to enable ctrl-alt-del handling: %m");
332
fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
334
/* Support systems without virtual console */
336
log_warning("Failed to open /dev/tty0: %m");
338
/* Enable that we get SIGWINCH on kbrequest */
339
if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
340
log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
342
close_nointr_nofail(fd);
348
static int manager_setup_signals(Manager *m) {
350
struct epoll_event ev = {
352
.data.ptr = &m->signal_watch,
354
struct sigaction sa = {
355
.sa_handler = SIG_DFL,
356
.sa_flags = SA_NOCLDSTOP|SA_RESTART,
361
/* We are not interested in SIGSTOP and friends. */
362
assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
364
assert_se(sigemptyset(&mask) == 0);
366
sigset_add_many(&mask,
367
SIGCHLD, /* Child died */
368
SIGTERM, /* Reexecute daemon */
369
SIGHUP, /* Reload configuration */
370
SIGUSR1, /* systemd/upstart: reconnect to D-Bus */
371
SIGUSR2, /* systemd: dump status */
372
SIGINT, /* Kernel sends us this on control-alt-del */
373
SIGWINCH, /* Kernel sends us this on kbrequest (alt-arrowup) */
374
SIGPWR, /* Some kernel drivers and upsd send us this on power failure */
375
SIGRTMIN+0, /* systemd: start default.target */
376
SIGRTMIN+1, /* systemd: isolate rescue.target */
377
SIGRTMIN+2, /* systemd: isolate emergency.target */
378
SIGRTMIN+3, /* systemd: start halt.target */
379
SIGRTMIN+4, /* systemd: start poweroff.target */
380
SIGRTMIN+5, /* systemd: start reboot.target */
381
SIGRTMIN+6, /* systemd: start kexec.target */
382
SIGRTMIN+13, /* systemd: Immediate halt */
383
SIGRTMIN+14, /* systemd: Immediate poweroff */
384
SIGRTMIN+15, /* systemd: Immediate reboot */
385
SIGRTMIN+16, /* systemd: Immediate kexec */
386
SIGRTMIN+20, /* systemd: enable status messages */
387
SIGRTMIN+21, /* systemd: disable status messages */
388
SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
389
SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
390
SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
391
SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
392
SIGRTMIN+27, /* systemd: set log target to console */
393
SIGRTMIN+28, /* systemd: set log target to kmsg */
394
SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
396
assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
398
m->signal_watch.type = WATCH_SIGNAL;
399
m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
400
if (m->signal_watch.fd < 0)
403
if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
406
if (m->running_as == SYSTEMD_SYSTEM)
407
return enable_special_signals(m);
412
static void manager_strip_environment(Manager *m) {
415
/* Remove variables from the inherited set that are part of
416
* the container interface:
417
* http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
418
strv_remove_prefix(m->environment, "container=");
419
strv_remove_prefix(m->environment, "container_");
421
/* Remove variables from the inherited set that are part of
422
* the initrd interface:
423
* http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
424
strv_remove_prefix(m->environment, "RD_");
426
/* Drop invalid entries */
427
strv_env_clean(m->environment);
430
int manager_new(SystemdRunningAs running_as, Manager **_m) {
435
assert(running_as >= 0);
436
assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
438
m = new0(Manager, 1);
442
m->running_as = running_as;
443
m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
444
m->exit_code = _MANAGER_EXIT_CODE_INVALID;
445
m->pin_cgroupfs_fd = -1;
446
m->idle_pipe[0] = m->idle_pipe[1] = -1;
448
watch_init(&m->signal_watch);
449
watch_init(&m->mount_watch);
450
watch_init(&m->swap_watch);
451
watch_init(&m->udev_watch);
452
watch_init(&m->time_change_watch);
453
watch_init(&m->jobs_in_progress_watch);
455
m->epoll_fd = m->dev_autofs_fd = -1;
456
m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
458
m->environment = strv_copy(environ);
462
manager_strip_environment(m);
464
if (running_as == SYSTEMD_SYSTEM) {
465
m->default_controllers = strv_new("cpu", NULL);
466
if (!m->default_controllers)
470
if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
473
if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
476
if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
479
if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
482
if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
485
m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
489
r = manager_setup_signals(m);
493
r = manager_setup_cgroup(m);
497
r = manager_setup_notify(m);
501
r = manager_setup_time_change(m);
505
/* Try to connect to the busses, if possible. */
506
r = bus_init(m, running_as != SYSTEMD_SYSTEM);
510
m->taint_usr = dir_is_empty("/usr") > 0;
520
static unsigned manager_dispatch_cleanup_queue(Manager *m) {
526
while ((u = m->cleanup_queue)) {
527
assert(u->in_cleanup_queue);
537
GC_OFFSET_IN_PATH, /* This one is on the path we were traveling */
538
GC_OFFSET_UNSURE, /* No clue */
539
GC_OFFSET_GOOD, /* We still need this unit */
540
GC_OFFSET_BAD, /* We don't need this unit anymore */
544
static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
551
if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
552
u->gc_marker == gc_marker + GC_OFFSET_BAD ||
553
u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
556
if (u->in_cleanup_queue)
559
if (unit_check_gc(u))
562
u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
566
SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
567
unit_gc_sweep(other, gc_marker);
569
if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
572
if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
579
/* We were unable to find anything out about this entry, so
580
* let's investigate it later */
581
u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
582
unit_add_to_gc_queue(u);
586
/* We definitely know that this one is not useful anymore, so
587
* let's mark it for deletion */
588
u->gc_marker = gc_marker + GC_OFFSET_BAD;
589
unit_add_to_cleanup_queue(u);
593
u->gc_marker = gc_marker + GC_OFFSET_GOOD;
596
static unsigned manager_dispatch_gc_queue(Manager *m) {
603
if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
604
(m->gc_queue_timestamp <= 0 ||
605
(m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
608
log_debug("Running GC...");
610
m->gc_marker += _GC_OFFSET_MAX;
611
if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
614
gc_marker = m->gc_marker;
616
while ((u = m->gc_queue)) {
617
assert(u->in_gc_queue);
619
unit_gc_sweep(u, gc_marker);
621
LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
622
u->in_gc_queue = false;
626
if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
627
u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
628
log_debug_unit(u->id, "Collecting %s", u->id);
629
u->gc_marker = gc_marker + GC_OFFSET_BAD;
630
unit_add_to_cleanup_queue(u);
634
m->n_in_gc_queue = 0;
635
m->gc_queue_timestamp = 0;
640
static void manager_clear_jobs_and_units(Manager *m) {
645
while ((u = hashmap_first(m->units)))
648
manager_dispatch_cleanup_queue(m);
650
assert(!m->load_queue);
651
assert(!m->run_queue);
652
assert(!m->dbus_unit_queue);
653
assert(!m->dbus_job_queue);
654
assert(!m->cleanup_queue);
655
assert(!m->gc_queue);
657
assert(hashmap_isempty(m->jobs));
658
assert(hashmap_isempty(m->units));
661
m->n_running_jobs = 0;
664
void manager_free(Manager *m) {
670
manager_clear_jobs_and_units(m);
672
for (c = 0; c < _UNIT_TYPE_MAX; c++)
673
if (unit_vtable[c]->shutdown)
674
unit_vtable[c]->shutdown(m);
676
/* If we reexecute ourselves, we keep the root cgroup
678
manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
680
manager_undo_generators(m);
684
hashmap_free(m->units);
685
hashmap_free(m->jobs);
686
hashmap_free(m->watch_pids);
687
hashmap_free(m->watch_bus);
689
if (m->epoll_fd >= 0)
690
close_nointr_nofail(m->epoll_fd);
691
if (m->signal_watch.fd >= 0)
692
close_nointr_nofail(m->signal_watch.fd);
693
if (m->notify_watch.fd >= 0)
694
close_nointr_nofail(m->notify_watch.fd);
695
if (m->time_change_watch.fd >= 0)
696
close_nointr_nofail(m->time_change_watch.fd);
697
if (m->jobs_in_progress_watch.fd >= 0)
698
close_nointr_nofail(m->jobs_in_progress_watch.fd);
700
free(m->notify_socket);
702
lookup_paths_free(&m->lookup_paths);
703
strv_free(m->environment);
705
strv_free(m->default_controllers);
707
hashmap_free(m->cgroup_bondings);
708
set_free_free(m->unit_path_cache);
710
close_pipe(m->idle_pipe);
712
free(m->switch_root);
713
free(m->switch_root_init);
715
for (i = 0; i < RLIMIT_NLIMITS; i++)
721
int manager_enumerate(Manager *m) {
727
/* Let's ask every type to load all units from disk/kernel
728
* that it might know */
729
for (c = 0; c < _UNIT_TYPE_MAX; c++)
730
if (unit_vtable[c]->enumerate)
731
if ((q = unit_vtable[c]->enumerate(m)) < 0)
734
manager_dispatch_load_queue(m);
738
int manager_coldplug(Manager *m) {
746
/* Then, let's set up their initial state. */
747
HASHMAP_FOREACH_KEY(u, k, m->units, i) {
753
if ((q = unit_coldplug(u)) < 0)
760
static void manager_build_unit_path_cache(Manager *m) {
762
_cleanup_free_ DIR *d = NULL;
767
set_free_free(m->unit_path_cache);
769
m->unit_path_cache = set_new(string_hash_func, string_compare_func);
770
if (!m->unit_path_cache) {
771
log_error("Failed to allocate unit path cache.");
775
/* This simply builds a list of files we know exist, so that
776
* we don't always have to go to disk */
778
STRV_FOREACH(i, m->lookup_paths.unit_path) {
784
log_error("Failed to open directory %s: %m", *i);
788
while ((de = readdir(d))) {
791
if (ignore_file(de->d_name))
794
p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
800
r = set_consume(m->unit_path_cache, p);
812
log_error("Failed to build unit path cache: %s", strerror(-r));
814
set_free_free(m->unit_path_cache);
815
m->unit_path_cache = NULL;
818
int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
823
manager_run_generators(m);
825
r = lookup_paths_init(
826
&m->lookup_paths, m->running_as, true,
827
m->generator_unit_path,
828
m->generator_unit_path_early,
829
m->generator_unit_path_late);
833
manager_build_unit_path_cache(m);
835
/* If we will deserialize make sure that during enumeration
836
* this is already known, so we increase the counter here
841
/* First, enumerate what we can from all config files */
842
r = manager_enumerate(m);
844
/* Second, deserialize if there is something to deserialize */
846
q = manager_deserialize(m, serialization, fds);
851
/* Any fds left? Find some unit which wants them. This is
852
* useful to allow container managers to pass some file
853
* descriptors to us pre-initialized. This enables
854
* socket-based activation of entire containers. */
855
if (fdset_size(fds) > 0) {
856
q = manager_distribute_fds(m, fds);
861
/* Third, fire things up! */
862
q = manager_coldplug(m);
867
assert(m->n_reloading > 0);
874
int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
879
assert(type < _JOB_TYPE_MAX);
881
assert(mode < _JOB_MODE_MAX);
883
if (mode == JOB_ISOLATE && type != JOB_START) {
884
dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
888
if (mode == JOB_ISOLATE && !unit->allow_isolate) {
889
dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
893
log_debug_unit(unit->id,
894
"Trying to enqueue job %s/%s/%s", unit->id,
895
job_type_to_string(type), job_mode_to_string(mode));
897
job_type_collapse(&type, unit);
899
tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
903
r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
904
mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
905
mode == JOB_IGNORE_DEPENDENCIES, e);
909
if (mode == JOB_ISOLATE) {
910
r = transaction_add_isolate_jobs(tr, m);
915
r = transaction_activate(tr, m, mode, e);
919
log_debug_unit(unit->id,
920
"Enqueued job %s/%s as %u", unit->id,
921
job_type_to_string(type), (unsigned) tr->anchor_job->id);
924
*_ret = tr->anchor_job;
926
transaction_free(tr);
930
transaction_abort(tr);
931
transaction_free(tr);
935
int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
940
assert(type < _JOB_TYPE_MAX);
942
assert(mode < _JOB_MODE_MAX);
944
r = manager_load_unit(m, name, NULL, NULL, &unit);
948
return manager_add_job(m, type, unit, mode, override, e, _ret);
951
Job *manager_get_job(Manager *m, uint32_t id) {
954
return hashmap_get(m->jobs, UINT32_TO_PTR(id));
957
Unit *manager_get_unit(Manager *m, const char *name) {
961
return hashmap_get(m->units, name);
964
unsigned manager_dispatch_load_queue(Manager *m) {
970
/* Make sure we are not run recursively */
971
if (m->dispatching_load_queue)
974
m->dispatching_load_queue = true;
976
/* Dispatches the load queue. Takes a unit from the queue and
977
* tries to load its data until the queue is empty */
979
while ((u = m->load_queue)) {
980
assert(u->in_load_queue);
986
m->dispatching_load_queue = false;
990
int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
996
assert(name || path);
998
/* This will prepare the unit for loading, but not actually
999
* load anything from disk. */
1001
if (path && !is_path(path)) {
1002
dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1007
name = path_get_file_name(path);
1009
t = unit_name_to_type(name);
1011
if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1012
dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1016
ret = manager_get_unit(m, name);
1022
ret = unit_new(m, unit_vtable[t]->object_size);
1027
ret->fragment_path = strdup(path);
1028
if (!ret->fragment_path) {
1034
if ((r = unit_add_name(ret, name)) < 0) {
1039
unit_add_to_load_queue(ret);
1040
unit_add_to_dbus_queue(ret);
1041
unit_add_to_gc_queue(ret);
1049
int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1054
/* This will load the service information files, but not actually
1055
* start any services or anything. */
1057
r = manager_load_unit_prepare(m, name, path, e, _ret);
1061
manager_dispatch_load_queue(m);
1064
*_ret = unit_follow_merge(*_ret);
1069
void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1076
HASHMAP_FOREACH(j, s->jobs, i)
1077
job_dump(j, f, prefix);
1080
void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1088
HASHMAP_FOREACH_KEY(u, t, s->units, i)
1090
unit_dump(u, f, prefix);
1093
void manager_clear_jobs(Manager *m) {
1098
while ((j = hashmap_first(m->jobs)))
1099
/* No need to recurse. We're cancelling all jobs. */
1100
job_finish_and_invalidate(j, JOB_CANCELED, false);
1103
unsigned manager_dispatch_run_queue(Manager *m) {
1107
if (m->dispatching_run_queue)
1110
m->dispatching_run_queue = true;
1112
while ((j = m->run_queue)) {
1113
assert(j->installed);
1114
assert(j->in_run_queue);
1116
job_run_and_invalidate(j);
1120
m->dispatching_run_queue = false;
1122
if (m->n_running_jobs > 0)
1123
manager_watch_jobs_in_progress(m);
1128
unsigned manager_dispatch_dbus_queue(Manager *m) {
1135
if (m->dispatching_dbus_queue)
1138
m->dispatching_dbus_queue = true;
1140
while ((u = m->dbus_unit_queue)) {
1141
assert(u->in_dbus_queue);
1143
bus_unit_send_change_signal(u);
1147
while ((j = m->dbus_job_queue)) {
1148
assert(j->in_dbus_queue);
1150
bus_job_send_change_signal(j);
1154
m->dispatching_dbus_queue = false;
1158
static int manager_process_notify_fd(Manager *m) {
1165
struct iovec iovec = {
1167
.iov_len = sizeof(buf)-1,
1171
struct cmsghdr cmsghdr;
1172
uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1175
struct msghdr msghdr = {
1178
.msg_control = &control,
1179
.msg_controllen = sizeof(control),
1181
struct ucred *ucred;
1183
_cleanup_strv_free_ char **tags = NULL;
1185
n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1190
if (errno == EAGAIN || errno == EINTR)
1196
if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1197
control.cmsghdr.cmsg_level != SOL_SOCKET ||
1198
control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1199
control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1200
log_warning("Received notify message without credentials. Ignoring.");
1204
ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1206
u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1208
u = cgroup_unit_by_pid(m, ucred->pid);
1210
log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1215
assert((size_t) n < sizeof(buf));
1217
tags = strv_split(buf, "\n\r");
1221
log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1223
if (UNIT_VTABLE(u)->notify_message)
1224
UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1230
static int manager_dispatch_sigchld(Manager *m) {
1238
/* First we call waitd() for a PID and do not reap the
1239
* zombie. That way we can still access /proc/$PID for
1240
* it while it is a zombie. */
1241
if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1243
if (errno == ECHILD)
1255
if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1256
_cleanup_free_ char *name = NULL;
1258
get_process_comm(si.si_pid, &name);
1259
log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1262
/* Let's flush any message the dying child might still
1263
* have queued for us. This ensures that the process
1264
* still exists in /proc so that we can figure out
1265
* which cgroup and hence unit it belongs to. */
1266
r = manager_process_notify_fd(m);
1270
/* And now figure out the unit this belongs to */
1271
u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1273
u = cgroup_unit_by_pid(m, si.si_pid);
1275
/* And now, we actually reap the zombie. */
1276
if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1283
if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1286
log_debug("Child %lu died (code=%s, status=%i/%s)",
1287
(long unsigned) si.si_pid,
1288
sigchld_code_to_string(si.si_code),
1290
strna(si.si_code == CLD_EXITED
1291
? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1292
: signal_to_string(si.si_status)));
1297
log_debug_unit(u->id,
1298
"Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1300
hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1301
UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1307
static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1311
dbus_error_init(&error);
1313
log_debug_unit(name, "Activating special unit %s", name);
1315
r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1317
log_error_unit(name,
1318
"Failed to enqueue %s job: %s", name, bus_error(&error, r));
1320
dbus_error_free(&error);
1325
static int manager_process_signal_fd(Manager *m) {
1327
struct signalfd_siginfo sfsi;
1328
bool sigchld = false;
1333
n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1334
if (n != sizeof(sfsi)) {
1339
if (errno == EINTR || errno == EAGAIN)
1345
if (sfsi.ssi_pid > 0) {
1348
get_process_comm(sfsi.ssi_pid, &p);
1350
log_debug("Received SIG%s from PID %lu (%s).",
1351
signal_to_string(sfsi.ssi_signo),
1352
(unsigned long) sfsi.ssi_pid, strna(p));
1355
log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1357
switch (sfsi.ssi_signo) {
1364
if (m->running_as == SYSTEMD_SYSTEM) {
1365
/* This is for compatibility with the
1366
* original sysvinit */
1367
m->exit_code = MANAGER_REEXECUTE;
1374
if (m->running_as == SYSTEMD_SYSTEM) {
1375
manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1379
/* Run the exit target if there is one, if not, just exit. */
1380
if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1381
m->exit_code = MANAGER_EXIT;
1388
if (m->running_as == SYSTEMD_SYSTEM)
1389
manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1391
/* This is a nop on non-init */
1395
if (m->running_as == SYSTEMD_SYSTEM)
1396
manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1398
/* This is a nop on non-init */
1404
u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1406
if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1407
log_info("Trying to reconnect to bus...");
1411
if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1412
log_info("Loading D-Bus service...");
1413
manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1424
if (!(f = open_memstream(&dump, &size))) {
1425
log_warning("Failed to allocate memory stream.");
1429
manager_dump_units(m, f, "\t");
1430
manager_dump_jobs(m, f, "\t");
1435
log_warning("Failed to write status stream");
1440
log_dump(LOG_INFO, dump);
1447
m->exit_code = MANAGER_RELOAD;
1452
/* Starting SIGRTMIN+0 */
1453
static const char * const target_table[] = {
1454
[0] = SPECIAL_DEFAULT_TARGET,
1455
[1] = SPECIAL_RESCUE_TARGET,
1456
[2] = SPECIAL_EMERGENCY_TARGET,
1457
[3] = SPECIAL_HALT_TARGET,
1458
[4] = SPECIAL_POWEROFF_TARGET,
1459
[5] = SPECIAL_REBOOT_TARGET,
1460
[6] = SPECIAL_KEXEC_TARGET
1463
/* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1464
static const ManagerExitCode code_table[] = {
1466
[1] = MANAGER_POWEROFF,
1467
[2] = MANAGER_REBOOT,
1471
if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1472
(int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1473
int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1474
manager_start_target(m, target_table[idx],
1475
(idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1479
if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1480
(int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1481
m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1485
switch (sfsi.ssi_signo - SIGRTMIN) {
1488
log_debug("Enabling showing of status.");
1489
manager_set_show_status(m, true);
1493
log_debug("Disabling showing of status.");
1494
manager_set_show_status(m, false);
1498
log_set_max_level(LOG_DEBUG);
1499
log_notice("Setting log level to debug.");
1503
log_set_max_level(LOG_INFO);
1504
log_notice("Setting log level to info.");
1508
if (m->running_as == SYSTEMD_USER) {
1509
m->exit_code = MANAGER_EXIT;
1513
/* This is a nop on init */
1517
log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1518
log_notice("Setting log target to journal-or-kmsg.");
1522
log_set_target(LOG_TARGET_CONSOLE);
1523
log_notice("Setting log target to console.");
1527
log_set_target(LOG_TARGET_KMSG);
1528
log_notice("Setting log target to kmsg.");
1532
log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1533
log_notice("Setting log target to syslog-or-kmsg.");
1537
log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1544
return manager_dispatch_sigchld(m);
1549
static int process_event(Manager *m, struct epoll_event *ev) {
1556
assert_se(w = ev->data.ptr);
1558
if (w->type == WATCH_INVALID)
1565
/* An incoming signal? */
1566
if (ev->events != EPOLLIN)
1569
if ((r = manager_process_signal_fd(m)) < 0)
1576
/* An incoming daemon notification event? */
1577
if (ev->events != EPOLLIN)
1580
if ((r = manager_process_notify_fd(m)) < 0)
1587
/* Some fd event, to be dispatched to the units */
1588
UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1591
case WATCH_UNIT_TIMER:
1592
case WATCH_JOB_TIMER: {
1596
/* Some timer event, to be dispatched to the units */
1597
k = read(w->fd, &v, sizeof(v));
1598
if (k != sizeof(v)) {
1600
if (k < 0 && (errno == EINTR || errno == EAGAIN))
1603
log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1604
return k < 0 ? -errno : -EIO;
1607
if (w->type == WATCH_UNIT_TIMER)
1608
UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1610
job_timer_event(w->data.job, v, w);
1615
/* Some mount table change, intended for the mount subsystem */
1616
mount_fd_event(m, ev->events);
1620
/* Some swap table change, intended for the swap subsystem */
1621
swap_fd_event(m, ev->events);
1625
/* Some notification from udev, intended for the device subsystem */
1626
device_fd_event(m, ev->events);
1629
case WATCH_DBUS_WATCH:
1630
bus_watch_event(m, w, ev->events);
1633
case WATCH_DBUS_TIMEOUT:
1634
bus_timeout_event(m, w, ev->events);
1637
case WATCH_TIME_CHANGE: {
1641
log_struct(LOG_INFO,
1642
MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1643
"MESSAGE=Time has been changed",
1646
/* Restart the watch */
1647
epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->time_change_watch.fd,
1649
close_nointr_nofail(m->time_change_watch.fd);
1650
watch_init(&m->time_change_watch);
1651
manager_setup_time_change(m);
1653
HASHMAP_FOREACH(u, m->units, i) {
1654
if (UNIT_VTABLE(u)->time_change)
1655
UNIT_VTABLE(u)->time_change(u);
1661
case WATCH_JOBS_IN_PROGRESS: {
1664
/* not interested in the data */
1665
read(w->fd, &v, sizeof(v));
1667
manager_print_jobs_in_progress(m);
1672
log_error("event type=%i", w->type);
1673
assert_not_reached("Unknown epoll event type.");
1679
int manager_loop(Manager *m) {
1682
RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1685
m->exit_code = MANAGER_RUNNING;
1687
/* Release the path cache */
1688
set_free_free(m->unit_path_cache);
1689
m->unit_path_cache = NULL;
1691
manager_check_finished(m);
1693
/* There might still be some zombies hanging around from
1694
* before we were exec()'ed. Leat's reap them */
1695
r = manager_dispatch_sigchld(m);
1699
while (m->exit_code == MANAGER_RUNNING) {
1700
struct epoll_event event;
1704
if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1707
if (!ratelimit_test(&rl)) {
1708
/* Yay, something is going seriously wrong, pause a little */
1709
log_warning("Looping too fast. Throttling execution a little.");
1714
if (manager_dispatch_load_queue(m) > 0)
1717
if (manager_dispatch_run_queue(m) > 0)
1720
if (bus_dispatch(m) > 0)
1723
if (manager_dispatch_cleanup_queue(m) > 0)
1726
if (manager_dispatch_gc_queue(m) > 0)
1729
if (manager_dispatch_dbus_queue(m) > 0)
1732
if (swap_dispatch_reload(m) > 0)
1735
/* Sleep for half the watchdog time */
1736
if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1737
wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1743
n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1755
r = process_event(m, &event);
1760
return m->exit_code;
1763
int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1772
if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1775
n = bus_path_unescape(s+31);
1779
r = manager_load_unit(m, n, NULL, e, &u);
1790
int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1799
if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1802
r = safe_atou(s + 30, &id);
1806
j = manager_get_job(m, id);
1815
void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1821
audit_fd = get_audit_fd();
1825
/* Don't generate audit events if the service was already
1826
* started and we're just deserializing */
1827
if (m->n_reloading > 0)
1830
if (m->running_as != SYSTEMD_SYSTEM)
1833
if (u->type != UNIT_SERVICE)
1836
p = unit_name_to_prefix_and_instance(u->id);
1838
log_error_unit(u->id,
1839
"Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1843
if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1844
if (errno == EPERM) {
1845
/* We aren't allowed to send audit messages?
1846
* Then let's not retry again. */
1849
log_warning("Failed to send audit message: %m");
1857
void manager_send_unit_plymouth(Manager *m, Unit *u) {
1859
union sockaddr_union sa;
1861
char *message = NULL;
1863
/* Don't generate plymouth events if the service was already
1864
* started and we're just deserializing */
1865
if (m->n_reloading > 0)
1868
if (m->running_as != SYSTEMD_SYSTEM)
1871
if (u->type != UNIT_SERVICE &&
1872
u->type != UNIT_MOUNT &&
1873
u->type != UNIT_SWAP)
1876
/* We set SOCK_NONBLOCK here so that we rather drop the
1877
* message then wait for plymouth */
1878
fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1880
log_error("socket() failed: %m");
1885
sa.sa.sa_family = AF_UNIX;
1886
strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1887
if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1889
if (errno != EPIPE &&
1892
errno != ECONNREFUSED &&
1893
errno != ECONNRESET &&
1894
errno != ECONNABORTED)
1895
log_error("connect() failed: %m");
1900
if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1906
if (write(fd, message, n + 1) != n + 1) {
1908
if (errno != EPIPE &&
1911
errno != ECONNREFUSED &&
1912
errno != ECONNRESET &&
1913
errno != ECONNABORTED)
1914
log_error("Failed to write Plymouth message: %m");
1921
close_nointr_nofail(fd);
1926
void manager_dispatch_bus_name_owner_changed(
1929
const char* old_owner,
1930
const char *new_owner) {
1937
if (!(u = hashmap_get(m->watch_bus, name)))
1940
UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1943
void manager_dispatch_bus_query_pid_done(
1954
if (!(u = hashmap_get(m->watch_bus, name)))
1957
UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1960
int manager_open_serialization(Manager *m, FILE **_f) {
1967
if (m->running_as == SYSTEMD_SYSTEM)
1968
asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1970
asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1975
RUN_WITH_UMASK(0077) {
1976
fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1986
log_debug("Serializing state to %s", path);
1989
f = fdopen(fd, "w+");
1998
int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2011
fprintf(f, "current-job-id=%i\n", m->current_job_id);
2012
fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2013
fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2014
fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2016
dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2017
dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2018
dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2019
dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2022
dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2023
dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2026
if (!switching_root) {
2027
STRV_FOREACH(e, m->environment) {
2028
_cleanup_free_ char *ce;
2032
fprintf(f, "env=%s\n", *e);
2038
HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2042
if (!unit_can_serialize(u))
2049
if ((r = unit_serialize(u, f, fds, !switching_root)) < 0) {
2055
assert(m->n_reloading > 0);
2061
r = bus_fdset_add_all(m, fds);
2068
int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2074
log_debug("Deserializing state...");
2079
char line[LINE_MAX], *l;
2081
if (!fgets(line, sizeof(line), f)) {
2096
if (startswith(l, "current-job-id=")) {
2099
if (safe_atou32(l+15, &id) < 0)
2100
log_debug("Failed to parse current job id value %s", l+15);
2102
m->current_job_id = MAX(m->current_job_id, id);
2103
} else if (startswith(l, "n-installed-jobs=")) {
2106
if (safe_atou32(l+17, &n) < 0)
2107
log_debug("Failed to parse installed jobs counter %s", l+17);
2109
m->n_installed_jobs += n;
2110
} else if (startswith(l, "n-failed-jobs=")) {
2113
if (safe_atou32(l+14, &n) < 0)
2114
log_debug("Failed to parse failed jobs counter %s", l+14);
2116
m->n_failed_jobs += n;
2117
} else if (startswith(l, "taint-usr=")) {
2120
if ((b = parse_boolean(l+10)) < 0)
2121
log_debug("Failed to parse taint /usr flag %s", l+10);
2123
m->taint_usr = m->taint_usr || b;
2124
} else if (startswith(l, "firmware-timestamp="))
2125
dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2126
else if (startswith(l, "loader-timestamp="))
2127
dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2128
else if (startswith(l, "kernel-timestamp="))
2129
dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2130
else if (startswith(l, "initrd-timestamp="))
2131
dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2132
else if (startswith(l, "userspace-timestamp="))
2133
dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2134
else if (startswith(l, "finish-timestamp="))
2135
dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2136
else if (startswith(l, "env=")) {
2137
_cleanup_free_ char *uce = NULL;
2140
uce = cunescape(l+4);
2146
e = strv_env_set(m->environment, uce);
2152
strv_free(m->environment);
2155
log_debug("Unknown serialization item '%s'", l);
2160
char name[UNIT_NAME_MAX+2];
2163
if (!fgets(name, sizeof(name), f)) {
2174
r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2178
r = unit_deserialize(u, f, fds);
2189
assert(m->n_reloading > 0);
2195
int manager_distribute_fds(Manager *m, FDSet *fds) {
2202
HASHMAP_FOREACH(u, m->units, i) {
2204
if (fdset_size(fds) <= 0)
2207
if (UNIT_VTABLE(u)->distribute_fds) {
2208
r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2217
int manager_reload(Manager *m) {
2224
r = manager_open_serialization(m, &f);
2237
r = manager_serialize(m, f, fds, false);
2243
if (fseeko(f, 0, SEEK_SET) < 0) {
2249
/* From here on there is no way back. */
2250
manager_clear_jobs_and_units(m);
2251
manager_undo_generators(m);
2252
lookup_paths_free(&m->lookup_paths);
2254
/* Find new unit paths */
2255
manager_run_generators(m);
2257
q = lookup_paths_init(
2258
&m->lookup_paths, m->running_as, true,
2259
m->generator_unit_path,
2260
m->generator_unit_path_early,
2261
m->generator_unit_path_late);
2265
manager_build_unit_path_cache(m);
2267
/* First, enumerate what we can from all config files */
2268
q = manager_enumerate(m);
2272
/* Second, deserialize our stored data */
2273
q = manager_deserialize(m, f, fds);
2280
/* Third, fire things up! */
2281
q = manager_coldplug(m);
2285
assert(m->n_reloading > 0);
2298
static bool manager_is_booting_or_shutting_down(Manager *m) {
2303
/* Is the initial job still around? */
2304
if (manager_get_job(m, m->default_unit_job_id))
2307
/* Is there a job for the shutdown target? */
2308
u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2315
bool manager_is_reloading_or_reexecuting(Manager *m) {
2318
return m->n_reloading != 0;
2321
void manager_reset_failed(Manager *m) {
2327
HASHMAP_FOREACH(u, m->units, i)
2328
unit_reset_failed(u);
2331
bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2337
/* Returns true if the unit is inactive or going down */
2338
u = manager_get_unit(m, name);
2342
return unit_inactive_or_pending(u);
2345
void manager_check_finished(Manager *m) {
2346
char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2347
usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2351
if (m->n_running_jobs == 0)
2352
manager_unwatch_jobs_in_progress(m);
2354
if (hashmap_size(m->jobs) > 0) {
2355
manager_jobs_in_progress_mod_timer(m);
2359
/* Notify Type=idle units that we are done now */
2360
close_pipe(m->idle_pipe);
2362
/* Turn off confirm spawn now */
2363
m->confirm_spawn = false;
2365
if (dual_timestamp_is_set(&m->finish_timestamp))
2368
dual_timestamp_get(&m->finish_timestamp);
2370
if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2372
/* Note that m->kernel_usec.monotonic is always at 0,
2373
* and m->firmware_usec.monotonic and
2374
* m->loader_usec.monotonic should be considered
2375
* negative values. */
2377
firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2378
loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2379
userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2380
total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2382
if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2384
kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2385
initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2387
if (!log_on_console())
2388
log_struct(LOG_INFO,
2389
MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2390
"KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2391
"INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2392
"USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2393
"MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2394
format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2395
format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2396
format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2397
format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2400
kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2403
if (!log_on_console())
2404
log_struct(LOG_INFO,
2405
MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2406
"KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2407
"USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2408
"MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2409
format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2410
format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2411
format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2415
firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2416
total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2418
if (!log_on_console())
2419
log_struct(LOG_INFO,
2420
MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2421
"USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2422
"MESSAGE=Startup finished in %s.",
2423
format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2427
bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2430
"READY=1\nSTATUS=Startup finished in %s.",
2431
format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2434
static int create_generator_dir(Manager *m, char **generator, const char *name) {
2445
if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2447
p = strappend("/run/systemd/", name);
2451
r = mkdir_p_label(p, 0755);
2453
log_error("Failed to create generator directory %s: %s",
2459
p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2464
log_error("Failed to create generator directory %s: %m",
2475
static void trim_generator_dir(Manager *m, char **generator) {
2482
if (rmdir(*generator) >= 0) {
2490
void manager_run_generators(Manager *m) {
2492
const char *generator_path;
2493
const char *argv[5];
2498
generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2499
d = opendir(generator_path);
2501
if (errno == ENOENT)
2504
log_error("Failed to enumerate generator directory %s: %m",
2509
r = create_generator_dir(m, &m->generator_unit_path, "generator");
2513
r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2517
r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2521
argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2522
argv[1] = m->generator_unit_path;
2523
argv[2] = m->generator_unit_path_early;
2524
argv[3] = m->generator_unit_path_late;
2527
RUN_WITH_UMASK(0022) {
2528
execute_directory(generator_path, d, (char**) argv);
2531
trim_generator_dir(m, &m->generator_unit_path);
2532
trim_generator_dir(m, &m->generator_unit_path_early);
2533
trim_generator_dir(m, &m->generator_unit_path_late);
2540
static void remove_generator_dir(Manager *m, char **generator) {
2547
strv_remove(m->lookup_paths.unit_path, *generator);
2548
rm_rf(*generator, false, true, false);
2554
void manager_undo_generators(Manager *m) {
2557
remove_generator_dir(m, &m->generator_unit_path);
2558
remove_generator_dir(m, &m->generator_unit_path_early);
2559
remove_generator_dir(m, &m->generator_unit_path_late);
2562
int manager_set_default_controllers(Manager *m, char **controllers) {
2567
l = strv_copy(controllers);
2571
strv_free(m->default_controllers);
2572
m->default_controllers = l;
2574
cg_shorten_controllers(m->default_controllers);
2579
int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2584
for (i = 0; i < RLIMIT_NLIMITS; i++) {
2585
if (!default_rlimit[i])
2588
m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2596
void manager_recheck_journal(Manager *m) {
2601
if (m->running_as != SYSTEMD_SYSTEM)
2604
u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2605
if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2606
log_close_journal();
2610
u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2611
if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2612
log_close_journal();
2616
/* Hmm, OK, so the socket is fully up and the service is up
2617
* too, then let's make use of the thing. */
2621
void manager_set_show_status(Manager *m, bool b) {
2624
if (m->running_as != SYSTEMD_SYSTEM)
2630
touch("/run/systemd/show-status");
2632
unlink("/run/systemd/show-status");
2635
static bool manager_get_show_status(Manager *m) {
2638
if (m->running_as != SYSTEMD_SYSTEM)
2644
/* If Plymouth is running make sure we show the status, so
2645
* that there's something nice to see when people press Esc */
2647
return plymouth_running();
2650
void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2653
if (!manager_get_show_status(m))
2656
/* XXX We should totally drop the check for ephemeral here
2657
* and thus effectively make 'Type=idle' pointless. */
2658
if (ephemeral && m->n_on_console > 0)
2661
if (!manager_is_booting_or_shutting_down(m))
2664
va_start(ap, format);
2665
status_vprintf(status, true, ephemeral, format, ap);
2669
void watch_init(Watch *w) {
2672
w->type = WATCH_INVALID;
added
removed
.pc/debian-changes/src/core/manager.c
