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                 if (!(d = opendir(*i))) {
 638                         log_error("Failed to open directory: %m");
 639                         continue;
 640                 }
 641
 642                 while ((de = readdir(d))) {
 643                         char *p;
 644
 645                         if (ignore_file(de->d_name))
 646                                 continue;
 647
 648                         p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
 649                         if (!p) {
 650                                 r = -ENOMEM;
 651                                 goto fail;
 652                         }
 653
 654                         if ((r = set_put(m->unit_path_cache, p)) < 0) {
 655                                 free(p);
 656                                 goto fail;
 657                         }
 658                 }
 659
 660                 closedir(d);
 661                 d = NULL;
 662         }
 663
 664         return;
 665
 666 fail:
 667         log_error("Failed to build unit path cache: %s", strerror(-r));
 668
 669         set_free_free(m->unit_path_cache);
 670         m->unit_path_cache = NULL;
 671
 672         if (d)
 673                 closedir(d);
 674 }
 675
 676 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
 677         int r, q;
 678
 679         assert(m);
 680
 681         manager_run_generators(m);
 682
 683         r = lookup_paths_init(
 684                         &m->lookup_paths, m->running_as, true,
 685                         m->generator_unit_path,
 686                         m->generator_unit_path_early,
 687                         m->generator_unit_path_late);
 688         if (r < 0)
 689                 return r;
 690
 691         manager_build_unit_path_cache(m);
 692
 693         /* If we will deserialize make sure that during enumeration
 694          * this is already known, so we increase the counter here
 695          * already */
 696         if (serialization)
 697                 m->n_reloading ++;
 698
 699         /* First, enumerate what we can from all config files */
 700         r = manager_enumerate(m);
 701
 702         /* Second, deserialize if there is something to deserialize */
 703         if (serialization) {
 704                 q = manager_deserialize(m, serialization, fds);
 705                 if (q < 0)
 706                         r = q;
 707         }
 708
 709         /* Any fds left? Find some unit which wants them. This is
 710          * useful to allow container managers to pass some file
 711          * descriptors to us pre-initialized. This enables
 712          * socket-based activation of entire containers. */
 713         if (fdset_size(fds) > 0) {
 714                 q = manager_distribute_fds(m, fds);
 715                 if (q < 0)
 716                         r = q;
 717         }
 718
 719         /* Third, fire things up! */
 720         q = manager_coldplug(m);
 721         if (q < 0)
 722                 r = q;
 723
 724         if (serialization) {
 725                 assert(m->n_reloading > 0);
 726                 m->n_reloading --;
 727         }
 728
 729         return r;
 730 }
 731
 732 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
 733         int r;
 734         Transaction *tr;
 735
 736         assert(m);
 737         assert(type < _JOB_TYPE_MAX);
 738         assert(unit);
 739         assert(mode < _JOB_MODE_MAX);
 740
 741         if (mode == JOB_ISOLATE && type != JOB_START) {
 742                 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
 743                 return -EINVAL;
 744         }
 745
 746         if (mode == JOB_ISOLATE && !unit->allow_isolate) {
 747                 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
 748                 return -EPERM;
 749         }
 750
 751         log_debug("Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
 752
 753         job_type_collapse(&type, unit);
 754
 755         tr = transaction_new();
 756         if (!tr)
 757                 return -ENOMEM;
 758
 759         r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
 760                                                  mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
 761                                                  mode == JOB_IGNORE_DEPENDENCIES, e);
 762         if (r < 0)
 763                 goto tr_abort;
 764
 765         if (mode == JOB_ISOLATE) {
 766                 r = transaction_add_isolate_jobs(tr, m);
 767                 if (r < 0)
 768                         goto tr_abort;
 769         }
 770
 771         r = transaction_activate(tr, m, mode, e);
 772         if (r < 0)
 773                 goto tr_abort;
 774
 775         log_debug("Enqueued job %s/%s as %u", unit->id, job_type_to_string(type), (unsigned) tr->anchor_job->id);
 776
 777         if (_ret)
 778                 *_ret = tr->anchor_job;
 779
 780         transaction_free(tr);
 781         return 0;
 782
 783 tr_abort:
 784         transaction_abort(tr);
 785         transaction_free(tr);
 786         return r;
 787 }
 788
 789 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
 790         Unit *unit;
 791         int r;
 792
 793         assert(m);
 794         assert(type < _JOB_TYPE_MAX);
 795         assert(name);
 796         assert(mode < _JOB_MODE_MAX);
 797
 798         r = manager_load_unit(m, name, NULL, NULL, &unit);
 799         if (r < 0)
 800                 return r;
 801
 802         return manager_add_job(m, type, unit, mode, override, e, _ret);
 803 }
 804
 805 Job *manager_get_job(Manager *m, uint32_t id) {
 806         assert(m);
 807
 808         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
 809 }
 810
 811 Unit *manager_get_unit(Manager *m, const char *name) {
 812         assert(m);
 813         assert(name);
 814
 815         return hashmap_get(m->units, name);
 816 }
 817
 818 unsigned manager_dispatch_load_queue(Manager *m) {
 819         Unit *u;
 820         unsigned n = 0;
 821
 822         assert(m);
 823
 824         /* Make sure we are not run recursively */
 825         if (m->dispatching_load_queue)
 826                 return 0;
 827
 828         m->dispatching_load_queue = true;
 829
 830         /* Dispatches the load queue. Takes a unit from the queue and
 831          * tries to load its data until the queue is empty */
 832
 833         while ((u = m->load_queue)) {
 834                 assert(u->in_load_queue);
 835
 836                 unit_load(u);
 837                 n++;
 838         }
 839
 840         m->dispatching_load_queue = false;
 841         return n;
 842 }
 843
 844 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
 845         Unit *ret;
 846         UnitType t;
 847         int r;
 848
 849         assert(m);
 850         assert(name || path);
 851
 852         /* This will prepare the unit for loading, but not actually
 853          * load anything from disk. */
 854
 855         if (path && !is_path(path)) {
 856                 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
 857                 return -EINVAL;
 858         }
 859
 860         if (!name)
 861                 name = path_get_file_name(path);
 862
 863         t = unit_name_to_type(name);
 864
 865         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
 866                 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
 867                 return -EINVAL;
 868         }
 869
 870         ret = manager_get_unit(m, name);
 871         if (ret) {
 872                 *_ret = ret;
 873                 return 1;
 874         }
 875
 876         ret = unit_new(m, unit_vtable[t]->object_size);
 877         if (!ret)
 878                 return -ENOMEM;
 879
 880         if (path) {
 881                 ret->fragment_path = strdup(path);
 882                 if (!ret->fragment_path) {
 883                         unit_free(ret);
 884                         return -ENOMEM;
 885                 }
 886         }
 887
 888         if ((r = unit_add_name(ret, name)) < 0) {
 889                 unit_free(ret);
 890                 return r;
 891         }
 892
 893         unit_add_to_load_queue(ret);
 894         unit_add_to_dbus_queue(ret);
 895         unit_add_to_gc_queue(ret);
 896
 897         if (_ret)
 898                 *_ret = ret;
 899
 900         return 0;
 901 }
 902
 903 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
 904         int r;
 905
 906         assert(m);
 907
 908         /* This will load the service information files, but not actually
 909          * start any services or anything. */
 910
 911         r = manager_load_unit_prepare(m, name, path, e, _ret);
 912         if (r != 0)
 913                 return r;
 914
 915         manager_dispatch_load_queue(m);
 916
 917         if (_ret)
 918                 *_ret = unit_follow_merge(*_ret);
 919
 920         return 0;
 921 }
 922
 923 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
 924         Iterator i;
 925         Job *j;
 926
 927         assert(s);
 928         assert(f);
 929
 930         HASHMAP_FOREACH(j, s->jobs, i)
 931                 job_dump(j, f, prefix);
 932 }
 933
 934 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
 935         Iterator i;
 936         Unit *u;
 937         const char *t;
 938
 939         assert(s);
 940         assert(f);
 941
 942         HASHMAP_FOREACH_KEY(u, t, s->units, i)
 943                 if (u->id == t)
 944                         unit_dump(u, f, prefix);
 945 }
 946
 947 void manager_clear_jobs(Manager *m) {
 948         Job *j;
 949
 950         assert(m);
 951
 952         while ((j = hashmap_first(m->jobs)))
 953                 /* No need to recurse. We're cancelling all jobs. */
 954                 job_finish_and_invalidate(j, JOB_CANCELED, false);
 955 }
 956
 957 unsigned manager_dispatch_run_queue(Manager *m) {
 958         Job *j;
 959         unsigned n = 0;
 960
 961         if (m->dispatching_run_queue)
 962                 return 0;
 963
 964         m->dispatching_run_queue = true;
 965
 966         while ((j = m->run_queue)) {
 967                 assert(j->installed);
 968                 assert(j->in_run_queue);
 969
 970                 job_run_and_invalidate(j);
 971                 n++;
 972         }
 973
 974         m->dispatching_run_queue = false;
 975         return n;
 976 }
 977
 978 unsigned manager_dispatch_dbus_queue(Manager *m) {
 979         Job *j;
 980         Unit *u;
 981         unsigned n = 0;
 982
 983         assert(m);
 984
 985         if (m->dispatching_dbus_queue)
 986                 return 0;
 987
 988         m->dispatching_dbus_queue = true;
 989
 990         while ((u = m->dbus_unit_queue)) {
 991                 assert(u->in_dbus_queue);
 992
 993                 bus_unit_send_change_signal(u);
 994                 n++;
 995         }
 996
 997         while ((j = m->dbus_job_queue)) {
 998                 assert(j->in_dbus_queue);
 999
1000                 bus_job_send_change_signal(j);
1001                 n++;
1002         }
1003
1004         m->dispatching_dbus_queue = false;
1005         return n;
1006 }
1007
1008 static int manager_process_notify_fd(Manager *m) {
1009         ssize_t n;
1010
1011         assert(m);
1012
1013         for (;;) {
1014                 char buf[4096];
1015                 struct msghdr msghdr;
1016                 struct iovec iovec;
1017                 struct ucred *ucred;
1018                 union {
1019                         struct cmsghdr cmsghdr;
1020                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1021                 } control;
1022                 Unit *u;
1023                 char **tags;
1024
1025                 zero(iovec);
1026                 iovec.iov_base = buf;
1027                 iovec.iov_len = sizeof(buf)-1;
1028
1029                 zero(control);
1030                 zero(msghdr);
1031                 msghdr.msg_iov = &iovec;
1032                 msghdr.msg_iovlen = 1;
1033                 msghdr.msg_control = &control;
1034                 msghdr.msg_controllen = sizeof(control);
1035
1036                 if ((n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT)) <= 0) {
1037                         if (n >= 0)
1038                                 return -EIO;
1039
1040                         if (errno == EAGAIN || errno == EINTR)
1041                                 break;
1042
1043                         return -errno;
1044                 }
1045
1046                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1047                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
1048                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1049                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1050                         log_warning("Received notify message without credentials. Ignoring.");
1051                         continue;
1052                 }
1053
1054                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1055
1056                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid))))
1057                         if (!(u = cgroup_unit_by_pid(m, ucred->pid))) {
1058                                 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1059                                 continue;
1060                         }
1061
1062                 assert((size_t) n < sizeof(buf));
1063                 buf[n] = 0;
1064                 if (!(tags = strv_split(buf, "\n\r")))
1065                         return -ENOMEM;
1066
1067                 log_debug("Got notification message for unit %s", u->id);
1068
1069                 if (UNIT_VTABLE(u)->notify_message)
1070                         UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1071
1072                 strv_free(tags);
1073         }
1074
1075         return 0;
1076 }
1077
1078 static int manager_dispatch_sigchld(Manager *m) {
1079         assert(m);
1080
1081         for (;;) {
1082                 siginfo_t si;
1083                 Unit *u;
1084                 int r;
1085
1086                 zero(si);
1087
1088                 /* First we call waitd() for a PID and do not reap the
1089                  * zombie. That way we can still access /proc/$PID for
1090                  * it while it is a zombie. */
1091                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1092
1093                         if (errno == ECHILD)
1094                                 break;
1095
1096                         if (errno == EINTR)
1097                                 continue;
1098
1099                         return -errno;
1100                 }
1101
1102                 if (si.si_pid <= 0)
1103                         break;
1104
1105                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1106                         char *name = NULL;
1107
1108                         get_process_comm(si.si_pid, &name);
1109                         log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1110                         free(name);
1111                 }
1112
1113                 /* Let's flush any message the dying child might still
1114                  * have queued for us. This ensures that the process
1115                  * still exists in /proc so that we can figure out
1116                  * which cgroup and hence unit it belongs to. */
1117                 if ((r = manager_process_notify_fd(m)) < 0)
1118                         return r;
1119
1120                 /* And now figure out the unit this belongs to */
1121                 if (!(u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid))))
1122                         u = cgroup_unit_by_pid(m, si.si_pid);
1123
1124                 /* And now, we actually reap the zombie. */
1125                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1126                         if (errno == EINTR)
1127                                 continue;
1128
1129                         return -errno;
1130                 }
1131
1132                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1133                         continue;
1134
1135                 log_debug("Child %lu died (code=%s, status=%i/%s)",
1136                           (long unsigned) si.si_pid,
1137                           sigchld_code_to_string(si.si_code),
1138                           si.si_status,
1139                           strna(si.si_code == CLD_EXITED
1140                                 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1141                                 : signal_to_string(si.si_status)));
1142
1143                 if (!u)
1144                         continue;
1145
1146                 log_debug("Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1147
1148                 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1149                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1150         }
1151
1152         return 0;
1153 }
1154
1155 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1156         int r;
1157         DBusError error;
1158
1159         dbus_error_init(&error);
1160
1161         log_debug("Activating special unit %s", name);
1162
1163         if ((r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL)) < 0)
1164                 log_error("Failed to enqueue %s job: %s", name, bus_error(&error, r));
1165
1166         dbus_error_free(&error);
1167
1168         return r;
1169 }
1170
1171 static int manager_process_signal_fd(Manager *m) {
1172         ssize_t n;
1173         struct signalfd_siginfo sfsi;
1174         bool sigchld = false;
1175
1176         assert(m);
1177
1178         for (;;) {
1179                 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1180
1181                         if (n >= 0)
1182                                 return -EIO;
1183
1184                         if (errno == EINTR || errno == EAGAIN)
1185                                 break;
1186
1187                         return -errno;
1188                 }
1189
1190                 if (sfsi.ssi_pid > 0) {
1191                         char *p = NULL;
1192
1193                         get_process_comm(sfsi.ssi_pid, &p);
1194
1195                         log_debug("Received SIG%s from PID %lu (%s).",
1196                                   signal_to_string(sfsi.ssi_signo),
1197                                   (unsigned long) sfsi.ssi_pid, strna(p));
1198                         free(p);
1199                 } else
1200                         log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1201
1202                 switch (sfsi.ssi_signo) {
1203
1204                 case SIGCHLD:
1205                         sigchld = true;
1206                         break;
1207
1208                 case SIGTERM:
1209                         if (m->running_as == SYSTEMD_SYSTEM) {
1210                                 /* This is for compatibility with the
1211                                  * original sysvinit */
1212                                 m->exit_code = MANAGER_REEXECUTE;
1213                                 break;
1214                         }
1215
1216                         /* Fall through */
1217
1218                 case SIGINT:
1219                         if (m->running_as == SYSTEMD_SYSTEM) {
1220                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1221                                 break;
1222                         }
1223
1224                         /* Run the exit target if there is one, if not, just exit. */
1225                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1226                                 m->exit_code = MANAGER_EXIT;
1227                                 return 0;
1228                         }
1229
1230                         break;
1231
1232                 case SIGWINCH:
1233                         if (m->running_as == SYSTEMD_SYSTEM)
1234                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1235
1236                         /* This is a nop on non-init */
1237                         break;
1238
1239                 case SIGPWR:
1240                         if (m->running_as == SYSTEMD_SYSTEM)
1241                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1242
1243                         /* This is a nop on non-init */
1244                         break;
1245
1246                 case SIGUSR1: {
1247                         Unit *u;
1248
1249                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1250
1251                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1252                                 log_info("Trying to reconnect to bus...");
1253                                 bus_init(m, true);
1254                         }
1255
1256                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1257                                 log_info("Loading D-Bus service...");
1258                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1259                         }
1260
1261                         break;
1262                 }
1263
1264                 case SIGUSR2: {
1265                         FILE *f;
1266                         char *dump = NULL;
1267                         size_t size;
1268
1269                         if (!(f = open_memstream(&dump, &size))) {
1270                                 log_warning("Failed to allocate memory stream.");
1271                                 break;
1272                         }
1273
1274                         manager_dump_units(m, f, "\t");
1275                         manager_dump_jobs(m, f, "\t");
1276
1277                         if (ferror(f)) {
1278                                 fclose(f);
1279                                 free(dump);
1280                                 log_warning("Failed to write status stream");
1281                                 break;
1282                         }
1283
1284                         fclose(f);
1285                         log_dump(LOG_INFO, dump);
1286                         free(dump);
1287
1288                         break;
1289                 }
1290
1291                 case SIGHUP:
1292                         m->exit_code = MANAGER_RELOAD;
1293                         break;
1294
1295                 default: {
1296
1297                         /* Starting SIGRTMIN+0 */
1298                         static const char * const target_table[] = {
1299                                 [0] = SPECIAL_DEFAULT_TARGET,
1300                                 [1] = SPECIAL_RESCUE_TARGET,
1301                                 [2] = SPECIAL_EMERGENCY_TARGET,
1302                                 [3] = SPECIAL_HALT_TARGET,
1303                                 [4] = SPECIAL_POWEROFF_TARGET,
1304                                 [5] = SPECIAL_REBOOT_TARGET,
1305                                 [6] = SPECIAL_KEXEC_TARGET
1306                         };
1307
1308                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1309                         static const ManagerExitCode code_table[] = {
1310                                 [0] = MANAGER_HALT,
1311                                 [1] = MANAGER_POWEROFF,
1312                                 [2] = MANAGER_REBOOT,
1313                                 [3] = MANAGER_KEXEC
1314                         };
1315
1316                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1317                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1318                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1319                                 manager_start_target(m, target_table[idx],
1320                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1321                                 break;
1322                         }
1323
1324                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1325                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1326                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1327                                 break;
1328                         }
1329
1330                         switch (sfsi.ssi_signo - SIGRTMIN) {
1331
1332                         case 20:
1333                                 log_debug("Enabling showing of status.");
1334                                 manager_set_show_status(m, true);
1335                                 break;
1336
1337                         case 21:
1338                                 log_debug("Disabling showing of status.");
1339                                 manager_set_show_status(m, false);
1340                                 break;
1341
1342                         case 22:
1343                                 log_set_max_level(LOG_DEBUG);
1344                                 log_notice("Setting log level to debug.");
1345                                 break;
1346
1347                         case 23:
1348                                 log_set_max_level(LOG_INFO);
1349                                 log_notice("Setting log level to info.");
1350                                 break;
1351
1352                         case 24:
1353                                 if (m->running_as == SYSTEMD_USER) {
1354                                         m->exit_code = MANAGER_EXIT;
1355                                         return 0;
1356                                 }
1357
1358                                 /* This is a nop on init */
1359                                 break;
1360
1361                         case 26:
1362                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1363                                 log_notice("Setting log target to journal-or-kmsg.");
1364                                 break;
1365
1366                         case 27:
1367                                 log_set_target(LOG_TARGET_CONSOLE);
1368                                 log_notice("Setting log target to console.");
1369                                 break;
1370
1371                         case 28:
1372                                 log_set_target(LOG_TARGET_KMSG);
1373                                 log_notice("Setting log target to kmsg.");
1374                                 break;
1375
1376                         case 29:
1377                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1378                                 log_notice("Setting log target to syslog-or-kmsg.");
1379                                 break;
1380
1381                         default:
1382                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1383                         }
1384                 }
1385                 }
1386         }
1387
1388         if (sigchld)
1389                 return manager_dispatch_sigchld(m);
1390
1391         return 0;
1392 }
1393
1394 static int process_event(Manager *m, struct epoll_event *ev) {
1395         int r;
1396         Watch *w;
1397
1398         assert(m);
1399         assert(ev);
1400
1401         assert_se(w = ev->data.ptr);
1402
1403         if (w->type == WATCH_INVALID)
1404                 return 0;
1405
1406         switch (w->type) {
1407
1408         case WATCH_SIGNAL:
1409
1410                 /* An incoming signal? */
1411                 if (ev->events != EPOLLIN)
1412                         return -EINVAL;
1413
1414                 if ((r = manager_process_signal_fd(m)) < 0)
1415                         return r;
1416
1417                 break;
1418
1419         case WATCH_NOTIFY:
1420
1421                 /* An incoming daemon notification event? */
1422                 if (ev->events != EPOLLIN)
1423                         return -EINVAL;
1424
1425                 if ((r = manager_process_notify_fd(m)) < 0)
1426                         return r;
1427
1428                 break;
1429
1430         case WATCH_FD:
1431
1432                 /* Some fd event, to be dispatched to the units */
1433                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1434                 break;
1435
1436         case WATCH_UNIT_TIMER:
1437         case WATCH_JOB_TIMER: {
1438                 uint64_t v;
1439                 ssize_t k;
1440
1441                 /* Some timer event, to be dispatched to the units */
1442                 k = read(w->fd, &v, sizeof(v));
1443                 if (k != sizeof(v)) {
1444
1445                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
1446                                 break;
1447
1448                         log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1449                         return k < 0 ? -errno : -EIO;
1450                 }
1451
1452                 if (w->type == WATCH_UNIT_TIMER)
1453                         UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1454                 else
1455                         job_timer_event(w->data.job, v, w);
1456                 break;
1457         }
1458
1459         case WATCH_MOUNT:
1460                 /* Some mount table change, intended for the mount subsystem */
1461                 mount_fd_event(m, ev->events);
1462                 break;
1463
1464         case WATCH_SWAP:
1465                 /* Some swap table change, intended for the swap subsystem */
1466                 swap_fd_event(m, ev->events);
1467                 break;
1468
1469         case WATCH_UDEV:
1470                 /* Some notification from udev, intended for the device subsystem */
1471                 device_fd_event(m, ev->events);
1472                 break;
1473
1474         case WATCH_DBUS_WATCH:
1475                 bus_watch_event(m, w, ev->events);
1476                 break;
1477
1478         case WATCH_DBUS_TIMEOUT:
1479                 bus_timeout_event(m, w, ev->events);
1480                 break;
1481
1482         case WATCH_TIME_CHANGE: {
1483                 Unit *u;
1484                 Iterator i;
1485
1486                 log_struct(LOG_INFO,
1487                            MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1488                            "MESSAGE=Time has been changed",
1489                            NULL);
1490
1491                 /* Restart the watch */
1492                 close_nointr_nofail(m->time_change_watch.fd);
1493                 watch_init(&m->time_change_watch);
1494                 manager_setup_time_change(m);
1495
1496                 HASHMAP_FOREACH(u, m->units, i) {
1497                         if (UNIT_VTABLE(u)->time_change)
1498                                 UNIT_VTABLE(u)->time_change(u);
1499                 }
1500
1501                 break;
1502         }
1503
1504         default:
1505                 log_error("event type=%i", w->type);
1506                 assert_not_reached("Unknown epoll event type.");
1507         }
1508
1509         return 0;
1510 }
1511
1512 int manager_loop(Manager *m) {
1513         int r;
1514
1515         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1516
1517         assert(m);
1518         m->exit_code = MANAGER_RUNNING;
1519
1520         /* Release the path cache */
1521         set_free_free(m->unit_path_cache);
1522         m->unit_path_cache = NULL;
1523
1524         manager_check_finished(m);
1525
1526         /* There might still be some zombies hanging around from
1527          * before we were exec()'ed. Leat's reap them */
1528         r = manager_dispatch_sigchld(m);
1529         if (r < 0)
1530                 return r;
1531
1532         while (m->exit_code == MANAGER_RUNNING) {
1533                 struct epoll_event event;
1534                 int n;
1535                 int wait_msec = -1;
1536
1537                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1538                         watchdog_ping();
1539
1540                 if (!ratelimit_test(&rl)) {
1541                         /* Yay, something is going seriously wrong, pause a little */
1542                         log_warning("Looping too fast. Throttling execution a little.");
1543                         sleep(1);
1544                         continue;
1545                 }
1546
1547                 if (manager_dispatch_load_queue(m) > 0)
1548                         continue;
1549
1550                 if (manager_dispatch_run_queue(m) > 0)
1551                         continue;
1552
1553                 if (bus_dispatch(m) > 0)
1554                         continue;
1555
1556                 if (manager_dispatch_cleanup_queue(m) > 0)
1557                         continue;
1558
1559                 if (manager_dispatch_gc_queue(m) > 0)
1560                         continue;
1561
1562                 if (manager_dispatch_dbus_queue(m) > 0)
1563                         continue;
1564
1565                 if (swap_dispatch_reload(m) > 0)
1566                         continue;
1567
1568                 /* Sleep for half the watchdog time */
1569                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1570                         wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1571                         if (wait_msec <= 0)
1572                                 wait_msec = 1;
1573                 } else
1574                         wait_msec = -1;
1575
1576                 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1577                 if (n < 0) {
1578
1579                         if (errno == EINTR)
1580                                 continue;
1581
1582                         return -errno;
1583                 } else if (n == 0)
1584                         continue;
1585
1586                 assert(n == 1);
1587
1588                 r = process_event(m, &event);
1589                 if (r < 0)
1590                         return r;
1591         }
1592
1593         return m->exit_code;
1594 }
1595
1596 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1597         char *n;
1598         Unit *u;
1599         int r;
1600
1601         assert(m);
1602         assert(s);
1603         assert(_u);
1604
1605         if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1606                 return -EINVAL;
1607
1608         n = bus_path_unescape(s+31);
1609         if (!n)
1610                 return -ENOMEM;
1611
1612         r = manager_load_unit(m, n, NULL, e, &u);
1613         free(n);
1614
1615         if (r < 0)
1616                 return r;
1617
1618         *_u = u;
1619
1620         return 0;
1621 }
1622
1623 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1624         Job *j;
1625         unsigned id;
1626         int r;
1627
1628         assert(m);
1629         assert(s);
1630         assert(_j);
1631
1632         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1633                 return -EINVAL;
1634
1635         r = safe_atou(s + 30, &id);
1636         if (r < 0)
1637                 return r;
1638
1639         j = manager_get_job(m, id);
1640         if (!j)
1641                 return -ENOENT;
1642
1643         *_j = j;
1644
1645         return 0;
1646 }
1647
1648 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1649
1650 #ifdef HAVE_AUDIT
1651         char *p;
1652         int audit_fd;
1653
1654         audit_fd = get_audit_fd();
1655         if (audit_fd < 0)
1656                 return;
1657
1658         /* Don't generate audit events if the service was already
1659          * started and we're just deserializing */
1660         if (m->n_reloading > 0)
1661                 return;
1662
1663         if (m->running_as != SYSTEMD_SYSTEM)
1664                 return;
1665
1666         if (u->type != UNIT_SERVICE)
1667                 return;
1668
1669         if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1670                 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1671                 return;
1672         }
1673
1674         if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1675                 if (errno == EPERM) {
1676                         /* We aren't allowed to send audit messages?
1677                          * Then let's not retry again. */
1678                         close_audit_fd();
1679                 } else
1680                         log_warning("Failed to send audit message: %m");
1681         }
1682
1683         free(p);
1684 #endif
1685
1686 }
1687
1688 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1689         int fd = -1;
1690         union sockaddr_union sa;
1691         int n = 0;
1692         char *message = NULL;
1693
1694         /* Don't generate plymouth events if the service was already
1695          * started and we're just deserializing */
1696         if (m->n_reloading > 0)
1697                 return;
1698
1699         if (m->running_as != SYSTEMD_SYSTEM)
1700                 return;
1701
1702         if (u->type != UNIT_SERVICE &&
1703             u->type != UNIT_MOUNT &&
1704             u->type != UNIT_SWAP)
1705                 return;
1706
1707         /* We set SOCK_NONBLOCK here so that we rather drop the
1708          * message then wait for plymouth */
1709         if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1710                 log_error("socket() failed: %m");
1711                 return;
1712         }
1713
1714         zero(sa);
1715         sa.sa.sa_family = AF_UNIX;
1716         strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1717         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1718
1719                 if (errno != EPIPE &&
1720                     errno != EAGAIN &&
1721                     errno != ENOENT &&
1722                     errno != ECONNREFUSED &&
1723                     errno != ECONNRESET &&
1724                     errno != ECONNABORTED)
1725                         log_error("connect() failed: %m");
1726
1727                 goto finish;
1728         }
1729
1730         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1731                 log_oom();
1732                 goto finish;
1733         }
1734
1735         errno = 0;
1736         if (write(fd, message, n + 1) != n + 1) {
1737
1738                 if (errno != EPIPE &&
1739                     errno != EAGAIN &&
1740                     errno != ENOENT &&
1741                     errno != ECONNREFUSED &&
1742                     errno != ECONNRESET &&
1743                     errno != ECONNABORTED)
1744                         log_error("Failed to write Plymouth message: %m");
1745
1746                 goto finish;
1747         }
1748
1749 finish:
1750         if (fd >= 0)
1751                 close_nointr_nofail(fd);
1752
1753         free(message);
1754 }
1755
1756 void manager_dispatch_bus_name_owner_changed(
1757                 Manager *m,
1758                 const char *name,
1759                 const char* old_owner,
1760                 const char *new_owner) {
1761
1762         Unit *u;
1763
1764         assert(m);
1765         assert(name);
1766
1767         if (!(u = hashmap_get(m->watch_bus, name)))
1768                 return;
1769
1770         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1771 }
1772
1773 void manager_dispatch_bus_query_pid_done(
1774                 Manager *m,
1775                 const char *name,
1776                 pid_t pid) {
1777
1778         Unit *u;
1779
1780         assert(m);
1781         assert(name);
1782         assert(pid >= 1);
1783
1784         if (!(u = hashmap_get(m->watch_bus, name)))
1785                 return;
1786
1787         UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1788 }
1789
1790 int manager_open_serialization(Manager *m, FILE **_f) {
1791         char *path = NULL;
1792         mode_t saved_umask;
1793         int fd;
1794         FILE *f;
1795
1796         assert(_f);
1797
1798         if (m->running_as == SYSTEMD_SYSTEM)
1799                 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1800         else
1801                 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1802
1803         if (!path)
1804                 return -ENOMEM;
1805
1806         saved_umask = umask(0077);
1807         fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1808         umask(saved_umask);
1809
1810         if (fd < 0) {
1811                 free(path);
1812                 return -errno;
1813         }
1814
1815         unlink(path);
1816
1817         log_debug("Serializing state to %s", path);
1818         free(path);
1819
1820         f = fdopen(fd, "w+");
1821         if (!f)
1822                 return -errno;
1823
1824         *_f = f;
1825
1826         return 0;
1827 }
1828
1829 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1830         Iterator i;
1831         Unit *u;
1832         const char *t;
1833         int r;
1834
1835         assert(m);
1836         assert(f);
1837         assert(fds);
1838
1839         m->n_reloading ++;
1840
1841         fprintf(f, "current-job-id=%i\n", m->current_job_id);
1842         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1843         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1844         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1845
1846         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1847         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1848         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1849         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1850
1851         if (!in_initrd()) {
1852                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1853                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1854         }
1855
1856         fputc('\n', f);
1857
1858         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1859                 if (u->id != t)
1860                         continue;
1861
1862                 if (!unit_can_serialize(u))
1863                         continue;
1864
1865                 /* Start marker */
1866                 fputs(u->id, f);
1867                 fputc('\n', f);
1868
1869                 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1870                         m->n_reloading --;
1871                         return r;
1872                 }
1873         }
1874
1875         assert(m->n_reloading > 0);
1876         m->n_reloading --;
1877
1878         if (ferror(f))
1879                 return -EIO;
1880
1881         r = bus_fdset_add_all(m, fds);
1882         if (r < 0)
1883                 return r;
1884
1885         return 0;
1886 }
1887
1888 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1889         int r = 0;
1890
1891         assert(m);
1892         assert(f);
1893
1894         log_debug("Deserializing state...");
1895
1896         m->n_reloading ++;
1897
1898         for (;;) {
1899                 char line[LINE_MAX], *l;
1900
1901                 if (!fgets(line, sizeof(line), f)) {
1902                         if (feof(f))
1903                                 r = 0;
1904                         else
1905                                 r = -errno;
1906
1907                         goto finish;
1908                 }
1909
1910                 char_array_0(line);
1911                 l = strstrip(line);
1912
1913                 if (l[0] == 0)
1914                         break;
1915
1916                 if (startswith(l, "current-job-id=")) {
1917                         uint32_t id;
1918
1919                         if (safe_atou32(l+15, &id) < 0)
1920                                 log_debug("Failed to parse current job id value %s", l+15);
1921                         else
1922                                 m->current_job_id = MAX(m->current_job_id, id);
1923                 } else if (startswith(l, "n-installed-jobs=")) {
1924                         uint32_t n;
1925
1926                         if (safe_atou32(l+17, &n) < 0)
1927                                 log_debug("Failed to parse installed jobs counter %s", l+17);
1928                         else
1929                                 m->n_installed_jobs += n;
1930                 } else if (startswith(l, "n-failed-jobs=")) {
1931                         uint32_t n;
1932
1933                         if (safe_atou32(l+14, &n) < 0)
1934                                 log_debug("Failed to parse failed jobs counter %s", l+14);
1935                         else
1936                                 m->n_failed_jobs += n;
1937                 } else if (startswith(l, "taint-usr=")) {
1938                         int b;
1939
1940                         if ((b = parse_boolean(l+10)) < 0)
1941                                 log_debug("Failed to parse taint /usr flag %s", l+10);
1942                         else
1943                                 m->taint_usr = m->taint_usr || b;
1944                 } else if (startswith(l, "firmware-timestamp="))
1945                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1946                 else if (startswith(l, "loader-timestamp="))
1947                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1948                 else if (startswith(l, "kernel-timestamp="))
1949                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1950                 else if (startswith(l, "initrd-timestamp="))
1951                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1952                 else if (startswith(l, "userspace-timestamp="))
1953                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1954                 else if (startswith(l, "finish-timestamp="))
1955                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1956                 else
1957                         log_debug("Unknown serialization item '%s'", l);
1958         }
1959
1960         for (;;) {
1961                 Unit *u;
1962                 char name[UNIT_NAME_MAX+2];
1963
1964                 /* Start marker */
1965                 if (!fgets(name, sizeof(name), f)) {
1966                         if (feof(f))
1967                                 r = 0;
1968                         else
1969                                 r = -errno;
1970
1971                         goto finish;
1972                 }
1973
1974                 char_array_0(name);
1975
1976                 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1977                         goto finish;
1978
1979                 r = unit_deserialize(u, f, fds);
1980                 if (r < 0)
1981                         goto finish;
1982         }
1983
1984 finish:
1985         if (ferror(f)) {
1986                 r = -EIO;
1987                 goto finish;
1988         }
1989
1990         assert(m->n_reloading > 0);
1991         m->n_reloading --;
1992
1993         return r;
1994 }
1995
1996 int manager_distribute_fds(Manager *m, FDSet *fds) {
1997         Unit *u;
1998         Iterator i;
1999         int r;
2000
2001         assert(m);
2002
2003         HASHMAP_FOREACH(u, m->units, i) {
2004
2005                 if (fdset_size(fds) <= 0)
2006                         break;
2007
2008                 if (UNIT_VTABLE(u)->distribute_fds) {
2009                         r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2010                         if (r < 0)
2011                                 return r;
2012                 }
2013         }
2014
2015         return 0;
2016 }
2017
2018 int manager_reload(Manager *m) {
2019         int r, q;
2020         FILE *f;
2021         FDSet *fds;
2022
2023         assert(m);
2024
2025         r = manager_open_serialization(m, &f);
2026         if (r < 0)
2027                 return r;
2028
2029         m->n_reloading ++;
2030
2031         fds = fdset_new();
2032         if (!fds) {
2033                 m->n_reloading --;
2034                 r = -ENOMEM;
2035                 goto finish;
2036         }
2037
2038         r = manager_serialize(m, f, fds, true);
2039         if (r < 0) {
2040                 m->n_reloading --;
2041                 goto finish;
2042         }
2043
2044         if (fseeko(f, 0, SEEK_SET) < 0) {
2045                 m->n_reloading --;
2046                 r = -errno;
2047                 goto finish;
2048         }
2049
2050         /* From here on there is no way back. */
2051         manager_clear_jobs_and_units(m);
2052         manager_undo_generators(m);
2053         lookup_paths_free(&m->lookup_paths);
2054
2055         /* Find new unit paths */
2056         manager_run_generators(m);
2057
2058         q = lookup_paths_init(
2059                         &m->lookup_paths, m->running_as, true,
2060                         m->generator_unit_path,
2061                         m->generator_unit_path_early,
2062                         m->generator_unit_path_late);
2063         if (q < 0)
2064                 r = q;
2065
2066         manager_build_unit_path_cache(m);
2067
2068         /* First, enumerate what we can from all config files */
2069         q = manager_enumerate(m);
2070         if (q < 0)
2071                 r = q;
2072
2073         /* Second, deserialize our stored data */
2074         q = manager_deserialize(m, f, fds);
2075         if (q < 0)
2076                 r = q;
2077
2078         fclose(f);
2079         f = NULL;
2080
2081         /* Third, fire things up! */
2082         q = manager_coldplug(m);
2083         if (q < 0)
2084                 r = q;
2085
2086         assert(m->n_reloading > 0);
2087         m->n_reloading--;
2088
2089 finish:
2090         if (f)
2091                 fclose(f);
2092
2093         if (fds)
2094                 fdset_free(fds);
2095
2096         return r;
2097 }
2098
2099 bool manager_is_booting_or_shutting_down(Manager *m) {
2100         Unit *u;
2101
2102         assert(m);
2103
2104         /* Is the initial job still around? */
2105         if (manager_get_job(m, m->default_unit_job_id))
2106                 return true;
2107
2108         /* Is there a job for the shutdown target? */
2109         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2110         if (u)
2111                 return !!u->job;
2112
2113         return false;
2114 }
2115
2116 void manager_reset_failed(Manager *m) {
2117         Unit *u;
2118         Iterator i;
2119
2120         assert(m);
2121
2122         HASHMAP_FOREACH(u, m->units, i)
2123                 unit_reset_failed(u);
2124 }
2125
2126 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2127         Unit *u;
2128
2129         assert(m);
2130         assert(name);
2131
2132         /* Returns true if the unit is inactive or going down */
2133         if (!(u = manager_get_unit(m, name)))
2134                 return true;
2135
2136         return unit_pending_inactive(u);
2137 }
2138
2139 void manager_check_finished(Manager *m) {
2140         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2141         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2142
2143         assert(m);
2144
2145         if (hashmap_size(m->jobs) > 0)
2146                 return;
2147
2148         /* Notify Type=idle units that we are done now */
2149         close_pipe(m->idle_pipe);
2150
2151         /* Turn off confirm spawn now */
2152         m->confirm_spawn = false;
2153
2154         if (dual_timestamp_is_set(&m->finish_timestamp))
2155                 return;
2156
2157         dual_timestamp_get(&m->finish_timestamp);
2158
2159         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2160
2161                 /* Note that m->kernel_usec.monotonic is always at 0,
2162                  * and m->firmware_usec.monotonic and
2163                  * m->loader_usec.monotonic should be considered
2164                  * negative values. */
2165
2166                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2167                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2168                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2169                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2170
2171                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2172
2173                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2174                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2175
2176                         if (!log_on_console())
2177                                 log_struct(LOG_INFO,
2178                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2179                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2180                                            "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2181                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2182                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2183                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2184                                            format_timespan(initrd, sizeof(initrd), initrd_usec),
2185                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2186                                            format_timespan(sum, sizeof(sum), total_usec),
2187                                            NULL);
2188                 } else {
2189                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2190                         initrd_usec = 0;
2191
2192                         if (!log_on_console())
2193                                 log_struct(LOG_INFO,
2194                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2195                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2196                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2197                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2198                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2199                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2200                                            format_timespan(sum, sizeof(sum), total_usec),
2201                                            NULL);
2202                 }
2203         } else {
2204                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2205                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2206
2207                 if (!log_on_console())
2208                         log_struct(LOG_INFO,
2209                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2210                                    "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2211                                    "MESSAGE=Startup finished in %s.",
2212                                    format_timespan(sum, sizeof(sum), total_usec),
2213                                    NULL);
2214         }
2215
2216         bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2217
2218         sd_notifyf(false,
2219                    "READY=1\nSTATUS=Startup finished in %s.",
2220                    format_timespan(sum, sizeof(sum), total_usec));
2221 }
2222
2223 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2224         char *p;
2225         int r;
2226
2227         assert(m);
2228         assert(generator);
2229         assert(name);
2230
2231         if (*generator)
2232                 return 0;
2233
2234         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2235
2236                 p = strappend("/run/systemd/", name);
2237                 if (!p)
2238                         return log_oom();
2239
2240                 r = mkdir_p_label(p, 0755);
2241                 if (r < 0) {
2242                         log_error("Failed to create generator directory: %s", strerror(-r));
2243                         free(p);
2244                         return r;
2245                 }
2246         } else {
2247                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2248                 if (!p)
2249                         return log_oom();
2250
2251                 if (!mkdtemp(p)) {
2252                         free(p);
2253                         log_error("Failed to create generator directory: %m");
2254                         return -errno;
2255                 }
2256         }
2257
2258         *generator = p;
2259         return 0;
2260 }
2261
2262 static void trim_generator_dir(Manager *m, char **generator) {
2263         assert(m);
2264         assert(generator);
2265
2266         if (!*generator)
2267                 return;
2268
2269         if (rmdir(*generator) >= 0) {
2270                 free(*generator);
2271                 *generator = NULL;
2272         }
2273
2274         return;
2275 }
2276
2277 void manager_run_generators(Manager *m) {
2278         DIR *d = NULL;
2279         const char *generator_path;
2280         const char *argv[5];
2281         mode_t u;
2282         int r;
2283
2284         assert(m);
2285
2286         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2287         d = opendir(generator_path);
2288         if (!d) {
2289                 if (errno == ENOENT)
2290                         return;
2291
2292                 log_error("Failed to enumerate generator directory: %m");
2293                 return;
2294         }
2295
2296         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2297         if (r < 0)
2298                 goto finish;
2299
2300         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2301         if (r < 0)
2302                 goto finish;
2303
2304         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2305         if (r < 0)
2306                 goto finish;
2307
2308         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2309         argv[1] = m->generator_unit_path;
2310         argv[2] = m->generator_unit_path_early;
2311         argv[3] = m->generator_unit_path_late;
2312         argv[4] = NULL;
2313
2314         u = umask(0022);
2315         execute_directory(generator_path, d, (char**) argv);
2316         umask(u);
2317
2318         trim_generator_dir(m, &m->generator_unit_path);
2319         trim_generator_dir(m, &m->generator_unit_path_early);
2320         trim_generator_dir(m, &m->generator_unit_path_late);
2321
2322 finish:
2323         if (d)
2324                 closedir(d);
2325 }
2326
2327 static void remove_generator_dir(Manager *m, char **generator) {
2328         assert(m);
2329         assert(generator);
2330
2331         if (!*generator)
2332                 return;
2333
2334         strv_remove(m->lookup_paths.unit_path, *generator);
2335         rm_rf(*generator, false, true, false);
2336
2337         free(*generator);
2338         *generator = NULL;
2339 }
2340
2341 void manager_undo_generators(Manager *m) {
2342         assert(m);
2343
2344         remove_generator_dir(m, &m->generator_unit_path);
2345         remove_generator_dir(m, &m->generator_unit_path_early);
2346         remove_generator_dir(m, &m->generator_unit_path_late);
2347 }
2348
2349 int manager_set_default_controllers(Manager *m, char **controllers) {
2350         char **l;
2351
2352         assert(m);
2353
2354         l = strv_copy(controllers);
2355         if (!l)
2356                 return -ENOMEM;
2357
2358         strv_free(m->default_controllers);
2359         m->default_controllers = l;
2360
2361         cg_shorten_controllers(m->default_controllers);
2362
2363         return 0;
2364 }
2365
2366 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2367         int i;
2368
2369         assert(m);
2370
2371         for (i = 0; i < RLIMIT_NLIMITS; i++) {
2372                 if (!default_rlimit[i])
2373                         continue;
2374
2375                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2376                 if (!m->rlimit[i])
2377                         return -ENOMEM;
2378         }
2379
2380         return 0;
2381 }
2382
2383 void manager_recheck_journal(Manager *m) {
2384         Unit *u;
2385
2386         assert(m);
2387
2388         if (m->running_as != SYSTEMD_SYSTEM)
2389                 return;
2390
2391         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2392         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2393                 log_close_journal();
2394                 return;
2395         }
2396
2397         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2398         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2399                 log_close_journal();
2400                 return;
2401         }
2402
2403         /* Hmm, OK, so the socket is fully up and the service is up
2404          * too, then let's make use of the thing. */
2405         log_open();
2406 }
2407
2408 void manager_set_show_status(Manager *m, bool b) {
2409         assert(m);
2410
2411         if (m->running_as != SYSTEMD_SYSTEM)
2412                 return;
2413
2414         m->show_status = b;
2415
2416         if (b)
2417                 touch("/run/systemd/show-status");
2418         else
2419                 unlink("/run/systemd/show-status");
2420 }
2421
2422 bool manager_get_show_status(Manager *m) {
2423         assert(m);
2424
2425         if (m->running_as != SYSTEMD_SYSTEM)
2426                 return false;
2427
2428         if (m->show_status)
2429                 return true;
2430
2431         /* If Plymouth is running make sure we show the status, so
2432          * that there's something nice to see when people press Esc */
2433
2434         return plymouth_running();
2435 }
2436
2437 void watch_init(Watch *w) {
2438         assert(w);
2439
2440         w->type = WATCH_INVALID;
2441         w->fd = -1;
2442 }