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