src/core/manager.c

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