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         int r;
1860
1861         assert(m);
1862         assert(f);
1863         assert(fds);
1864
1865         m->n_reloading ++;
1866
1867         fprintf(f, "current-job-id=%i\n", m->current_job_id);
1868         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1869         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1870         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1871
1872         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1873         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1874         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1875         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1876
1877         if (!in_initrd()) {
1878                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1879                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1880         }
1881
1882         fputc('\n', f);
1883
1884         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1885                 if (u->id != t)
1886                         continue;
1887
1888                 if (!unit_can_serialize(u))
1889                         continue;
1890
1891                 /* Start marker */
1892                 fputs(u->id, f);
1893                 fputc('\n', f);
1894
1895                 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1896                         m->n_reloading --;
1897                         return r;
1898                 }
1899         }
1900
1901         assert(m->n_reloading > 0);
1902         m->n_reloading --;
1903
1904         if (ferror(f))
1905                 return -EIO;
1906
1907         r = bus_fdset_add_all(m, fds);
1908         if (r < 0)
1909                 return r;
1910
1911         return 0;
1912 }
1913
1914 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1915         int r = 0;
1916
1917         assert(m);
1918         assert(f);
1919
1920         log_debug("Deserializing state...");
1921
1922         m->n_reloading ++;
1923
1924         for (;;) {
1925                 char line[LINE_MAX], *l;
1926
1927                 if (!fgets(line, sizeof(line), f)) {
1928                         if (feof(f))
1929                                 r = 0;
1930                         else
1931                                 r = -errno;
1932
1933                         goto finish;
1934                 }
1935
1936                 char_array_0(line);
1937                 l = strstrip(line);
1938
1939                 if (l[0] == 0)
1940                         break;
1941
1942                 if (startswith(l, "current-job-id=")) {
1943                         uint32_t id;
1944
1945                         if (safe_atou32(l+15, &id) < 0)
1946                                 log_debug("Failed to parse current job id value %s", l+15);
1947                         else
1948                                 m->current_job_id = MAX(m->current_job_id, id);
1949                 } else if (startswith(l, "n-installed-jobs=")) {
1950                         uint32_t n;
1951
1952                         if (safe_atou32(l+17, &n) < 0)
1953                                 log_debug("Failed to parse installed jobs counter %s", l+17);
1954                         else
1955                                 m->n_installed_jobs += n;
1956                 } else if (startswith(l, "n-failed-jobs=")) {
1957                         uint32_t n;
1958
1959                         if (safe_atou32(l+14, &n) < 0)
1960                                 log_debug("Failed to parse failed jobs counter %s", l+14);
1961                         else
1962                                 m->n_failed_jobs += n;
1963                 } else if (startswith(l, "taint-usr=")) {
1964                         int b;
1965
1966                         if ((b = parse_boolean(l+10)) < 0)
1967                                 log_debug("Failed to parse taint /usr flag %s", l+10);
1968                         else
1969                                 m->taint_usr = m->taint_usr || b;
1970                 } else if (startswith(l, "firmware-timestamp="))
1971                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1972                 else if (startswith(l, "loader-timestamp="))
1973                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1974                 else if (startswith(l, "kernel-timestamp="))
1975                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1976                 else if (startswith(l, "initrd-timestamp="))
1977                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1978                 else if (startswith(l, "userspace-timestamp="))
1979                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1980                 else if (startswith(l, "finish-timestamp="))
1981                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1982                 else
1983                         log_debug("Unknown serialization item '%s'", l);
1984         }
1985
1986         for (;;) {
1987                 Unit *u;
1988                 char name[UNIT_NAME_MAX+2];
1989
1990                 /* Start marker */
1991                 if (!fgets(name, sizeof(name), f)) {
1992                         if (feof(f))
1993                                 r = 0;
1994                         else
1995                                 r = -errno;
1996
1997                         goto finish;
1998                 }
1999
2000                 char_array_0(name);
2001
2002                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2003                 if (r < 0)
2004                         goto finish;
2005
2006                 r = unit_deserialize(u, f, fds);
2007                 if (r < 0)
2008                         goto finish;
2009         }
2010
2011 finish:
2012         if (ferror(f)) {
2013                 r = -EIO;
2014                 goto finish;
2015         }
2016
2017         assert(m->n_reloading > 0);
2018         m->n_reloading --;
2019
2020         return r;
2021 }
2022
2023 int manager_distribute_fds(Manager *m, FDSet *fds) {
2024         Unit *u;
2025         Iterator i;
2026         int r;
2027
2028         assert(m);
2029
2030         HASHMAP_FOREACH(u, m->units, i) {
2031
2032                 if (fdset_size(fds) <= 0)
2033                         break;
2034
2035                 if (UNIT_VTABLE(u)->distribute_fds) {
2036                         r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2037                         if (r < 0)
2038                                 return r;
2039                 }
2040         }
2041
2042         return 0;
2043 }
2044
2045 int manager_reload(Manager *m) {
2046         int r, q;
2047         FILE *f;
2048         FDSet *fds;
2049
2050         assert(m);
2051
2052         r = manager_open_serialization(m, &f);
2053         if (r < 0)
2054                 return r;
2055
2056         m->n_reloading ++;
2057
2058         fds = fdset_new();
2059         if (!fds) {
2060                 m->n_reloading --;
2061                 r = -ENOMEM;
2062                 goto finish;
2063         }
2064
2065         r = manager_serialize(m, f, fds, true);
2066         if (r < 0) {
2067                 m->n_reloading --;
2068                 goto finish;
2069         }
2070
2071         if (fseeko(f, 0, SEEK_SET) < 0) {
2072                 m->n_reloading --;
2073                 r = -errno;
2074                 goto finish;
2075         }
2076
2077         /* From here on there is no way back. */
2078         manager_clear_jobs_and_units(m);
2079         manager_undo_generators(m);
2080         lookup_paths_free(&m->lookup_paths);
2081
2082         /* Find new unit paths */
2083         manager_run_generators(m);
2084
2085         q = lookup_paths_init(
2086                         &m->lookup_paths, m->running_as, true,
2087                         m->generator_unit_path,
2088                         m->generator_unit_path_early,
2089                         m->generator_unit_path_late);
2090         if (q < 0)
2091                 r = q;
2092
2093         manager_build_unit_path_cache(m);
2094
2095         /* First, enumerate what we can from all config files */
2096         q = manager_enumerate(m);
2097         if (q < 0)
2098                 r = q;
2099
2100         /* Second, deserialize our stored data */
2101         q = manager_deserialize(m, f, fds);
2102         if (q < 0)
2103                 r = q;
2104
2105         fclose(f);
2106         f = NULL;
2107
2108         /* Third, fire things up! */
2109         q = manager_coldplug(m);
2110         if (q < 0)
2111                 r = q;
2112
2113         assert(m->n_reloading > 0);
2114         m->n_reloading--;
2115
2116 finish:
2117         if (f)
2118                 fclose(f);
2119
2120         if (fds)
2121                 fdset_free(fds);
2122
2123         return r;
2124 }
2125
2126 bool manager_is_booting_or_shutting_down(Manager *m) {
2127         Unit *u;
2128
2129         assert(m);
2130
2131         /* Is the initial job still around? */
2132         if (manager_get_job(m, m->default_unit_job_id))
2133                 return true;
2134
2135         /* Is there a job for the shutdown target? */
2136         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2137         if (u)
2138                 return !!u->job;
2139
2140         return false;
2141 }
2142
2143 void manager_reset_failed(Manager *m) {
2144         Unit *u;
2145         Iterator i;
2146
2147         assert(m);
2148
2149         HASHMAP_FOREACH(u, m->units, i)
2150                 unit_reset_failed(u);
2151 }
2152
2153 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2154         Unit *u;
2155
2156         assert(m);
2157         assert(name);
2158
2159         /* Returns true if the unit is inactive or going down */
2160         u = manager_get_unit(m, name);
2161         if (!u)
2162                 return true;
2163
2164         return unit_pending_inactive(u);
2165 }
2166
2167 void manager_check_finished(Manager *m) {
2168         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2169         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2170
2171         assert(m);
2172
2173         if (hashmap_size(m->jobs) > 0)
2174                 return;
2175
2176         /* Notify Type=idle units that we are done now */
2177         close_pipe(m->idle_pipe);
2178
2179         /* Turn off confirm spawn now */
2180         m->confirm_spawn = false;
2181
2182         if (dual_timestamp_is_set(&m->finish_timestamp))
2183                 return;
2184
2185         dual_timestamp_get(&m->finish_timestamp);
2186
2187         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2188
2189                 /* Note that m->kernel_usec.monotonic is always at 0,
2190                  * and m->firmware_usec.monotonic and
2191                  * m->loader_usec.monotonic should be considered
2192                  * negative values. */
2193
2194                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2195                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2196                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2197                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2198
2199                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2200
2201                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2202                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2203
2204                         if (!log_on_console())
2205                                 log_struct(LOG_INFO,
2206                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2207                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2208                                            "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2209                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2210                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2211                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2212                                            format_timespan(initrd, sizeof(initrd), initrd_usec),
2213                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2214                                            format_timespan(sum, sizeof(sum), total_usec),
2215                                            NULL);
2216                 } else {
2217                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2218                         initrd_usec = 0;
2219
2220                         if (!log_on_console())
2221                                 log_struct(LOG_INFO,
2222                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2223                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2224                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2225                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2226                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2227                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2228                                            format_timespan(sum, sizeof(sum), total_usec),
2229                                            NULL);
2230                 }
2231         } else {
2232                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2233                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2234
2235                 if (!log_on_console())
2236                         log_struct(LOG_INFO,
2237                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2238                                    "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2239                                    "MESSAGE=Startup finished in %s.",
2240                                    format_timespan(sum, sizeof(sum), total_usec),
2241                                    NULL);
2242         }
2243
2244         bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2245
2246         sd_notifyf(false,
2247                    "READY=1\nSTATUS=Startup finished in %s.",
2248                    format_timespan(sum, sizeof(sum), total_usec));
2249 }
2250
2251 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2252         char *p;
2253         int r;
2254
2255         assert(m);
2256         assert(generator);
2257         assert(name);
2258
2259         if (*generator)
2260                 return 0;
2261
2262         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2263
2264                 p = strappend("/run/systemd/", name);
2265                 if (!p)
2266                         return log_oom();
2267
2268                 r = mkdir_p_label(p, 0755);
2269                 if (r < 0) {
2270                         log_error("Failed to create generator directory %s: %s",
2271                                   p, strerror(-r));
2272                         free(p);
2273                         return r;
2274                 }
2275         } else {
2276                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2277                 if (!p)
2278                         return log_oom();
2279
2280                 if (!mkdtemp(p)) {
2281                         free(p);
2282                         log_error("Failed to create generator directory %s: %m",
2283                                   p);
2284                         return -errno;
2285                 }
2286         }
2287
2288         *generator = p;
2289         return 0;
2290 }
2291
2292 static void trim_generator_dir(Manager *m, char **generator) {
2293         assert(m);
2294         assert(generator);
2295
2296         if (!*generator)
2297                 return;
2298
2299         if (rmdir(*generator) >= 0) {
2300                 free(*generator);
2301                 *generator = NULL;
2302         }
2303
2304         return;
2305 }
2306
2307 void manager_run_generators(Manager *m) {
2308         DIR *d = NULL;
2309         const char *generator_path;
2310         const char *argv[5];
2311         mode_t u;
2312         int r;
2313
2314         assert(m);
2315
2316         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2317         d = opendir(generator_path);
2318         if (!d) {
2319                 if (errno == ENOENT)
2320                         return;
2321
2322                 log_error("Failed to enumerate generator directory %s: %m",
2323                           generator_path);
2324                 return;
2325         }
2326
2327         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2328         if (r < 0)
2329                 goto finish;
2330
2331         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2332         if (r < 0)
2333                 goto finish;
2334
2335         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2336         if (r < 0)
2337                 goto finish;
2338
2339         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2340         argv[1] = m->generator_unit_path;
2341         argv[2] = m->generator_unit_path_early;
2342         argv[3] = m->generator_unit_path_late;
2343         argv[4] = NULL;
2344
2345         u = umask(0022);
2346         execute_directory(generator_path, d, (char**) argv);
2347         umask(u);
2348
2349         trim_generator_dir(m, &m->generator_unit_path);
2350         trim_generator_dir(m, &m->generator_unit_path_early);
2351         trim_generator_dir(m, &m->generator_unit_path_late);
2352
2353 finish:
2354         if (d)
2355                 closedir(d);
2356 }
2357
2358 static void remove_generator_dir(Manager *m, char **generator) {
2359         assert(m);
2360         assert(generator);
2361
2362         if (!*generator)
2363                 return;
2364
2365         strv_remove(m->lookup_paths.unit_path, *generator);
2366         rm_rf(*generator, false, true, false);
2367
2368         free(*generator);
2369         *generator = NULL;
2370 }
2371
2372 void manager_undo_generators(Manager *m) {
2373         assert(m);
2374
2375         remove_generator_dir(m, &m->generator_unit_path);
2376         remove_generator_dir(m, &m->generator_unit_path_early);
2377         remove_generator_dir(m, &m->generator_unit_path_late);
2378 }
2379
2380 int manager_set_default_controllers(Manager *m, char **controllers) {
2381         char **l;
2382
2383         assert(m);
2384
2385         l = strv_copy(controllers);
2386         if (!l)
2387                 return -ENOMEM;
2388
2389         strv_free(m->default_controllers);
2390         m->default_controllers = l;
2391
2392         cg_shorten_controllers(m->default_controllers);
2393
2394         return 0;
2395 }
2396
2397 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2398         int i;
2399
2400         assert(m);
2401
2402         for (i = 0; i < RLIMIT_NLIMITS; i++) {
2403                 if (!default_rlimit[i])
2404                         continue;
2405
2406                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2407                 if (!m->rlimit[i])
2408                         return -ENOMEM;
2409         }
2410
2411         return 0;
2412 }
2413
2414 void manager_recheck_journal(Manager *m) {
2415         Unit *u;
2416
2417         assert(m);
2418
2419         if (m->running_as != SYSTEMD_SYSTEM)
2420                 return;
2421
2422         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2423         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2424                 log_close_journal();
2425                 return;
2426         }
2427
2428         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2429         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2430                 log_close_journal();
2431                 return;
2432         }
2433
2434         /* Hmm, OK, so the socket is fully up and the service is up
2435          * too, then let's make use of the thing. */
2436         log_open();
2437 }
2438
2439 void manager_set_show_status(Manager *m, bool b) {
2440         assert(m);
2441
2442         if (m->running_as != SYSTEMD_SYSTEM)
2443                 return;
2444
2445         m->show_status = b;
2446
2447         if (b)
2448                 touch("/run/systemd/show-status");
2449         else
2450                 unlink("/run/systemd/show-status");
2451 }
2452
2453 bool manager_get_show_status(Manager *m) {
2454         assert(m);
2455
2456         if (m->running_as != SYSTEMD_SYSTEM)
2457                 return false;
2458
2459         if (m->show_status)
2460                 return true;
2461
2462         /* If Plymouth is running make sure we show the status, so
2463          * that there's something nice to see when people press Esc */
2464
2465         return plymouth_running();
2466 }
2467
2468 void watch_init(Watch *w) {
2469         assert(w);
2470
2471         w->type = WATCH_INVALID;
2472         w->fd = -1;
2473 }