src/core/manager.c

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