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                 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1180                 if (n != sizeof(sfsi)) {
1181
1182                         if (n >= 0)
1183                                 return -EIO;
1184
1185                         if (errno == EINTR || errno == EAGAIN)
1186                                 break;
1187
1188                         return -errno;
1189                 }
1190
1191                 if (sfsi.ssi_pid > 0) {
1192                         char *p = NULL;
1193
1194                         get_process_comm(sfsi.ssi_pid, &p);
1195
1196                         log_debug("Received SIG%s from PID %lu (%s).",
1197                                   signal_to_string(sfsi.ssi_signo),
1198                                   (unsigned long) sfsi.ssi_pid, strna(p));
1199                         free(p);
1200                 } else
1201                         log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1202
1203                 switch (sfsi.ssi_signo) {
1204
1205                 case SIGCHLD:
1206                         sigchld = true;
1207                         break;
1208
1209                 case SIGTERM:
1210                         if (m->running_as == SYSTEMD_SYSTEM) {
1211                                 /* This is for compatibility with the
1212                                  * original sysvinit */
1213                                 m->exit_code = MANAGER_REEXECUTE;
1214                                 break;
1215                         }
1216
1217                         /* Fall through */
1218
1219                 case SIGINT:
1220                         if (m->running_as == SYSTEMD_SYSTEM) {
1221                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1222                                 break;
1223                         }
1224
1225                         /* Run the exit target if there is one, if not, just exit. */
1226                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1227                                 m->exit_code = MANAGER_EXIT;
1228                                 return 0;
1229                         }
1230
1231                         break;
1232
1233                 case SIGWINCH:
1234                         if (m->running_as == SYSTEMD_SYSTEM)
1235                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1236
1237                         /* This is a nop on non-init */
1238                         break;
1239
1240                 case SIGPWR:
1241                         if (m->running_as == SYSTEMD_SYSTEM)
1242                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1243
1244                         /* This is a nop on non-init */
1245                         break;
1246
1247                 case SIGUSR1: {
1248                         Unit *u;
1249
1250                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1251
1252                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1253                                 log_info("Trying to reconnect to bus...");
1254                                 bus_init(m, true);
1255                         }
1256
1257                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1258                                 log_info("Loading D-Bus service...");
1259                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1260                         }
1261
1262                         break;
1263                 }
1264
1265                 case SIGUSR2: {
1266                         FILE *f;
1267                         char *dump = NULL;
1268                         size_t size;
1269
1270                         if (!(f = open_memstream(&dump, &size))) {
1271                                 log_warning("Failed to allocate memory stream.");
1272                                 break;
1273                         }
1274
1275                         manager_dump_units(m, f, "\t");
1276                         manager_dump_jobs(m, f, "\t");
1277
1278                         if (ferror(f)) {
1279                                 fclose(f);
1280                                 free(dump);
1281                                 log_warning("Failed to write status stream");
1282                                 break;
1283                         }
1284
1285                         fclose(f);
1286                         log_dump(LOG_INFO, dump);
1287                         free(dump);
1288
1289                         break;
1290                 }
1291
1292                 case SIGHUP:
1293                         m->exit_code = MANAGER_RELOAD;
1294                         break;
1295
1296                 default: {
1297
1298                         /* Starting SIGRTMIN+0 */
1299                         static const char * const target_table[] = {
1300                                 [0] = SPECIAL_DEFAULT_TARGET,
1301                                 [1] = SPECIAL_RESCUE_TARGET,
1302                                 [2] = SPECIAL_EMERGENCY_TARGET,
1303                                 [3] = SPECIAL_HALT_TARGET,
1304                                 [4] = SPECIAL_POWEROFF_TARGET,
1305                                 [5] = SPECIAL_REBOOT_TARGET,
1306                                 [6] = SPECIAL_KEXEC_TARGET
1307                         };
1308
1309                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1310                         static const ManagerExitCode code_table[] = {
1311                                 [0] = MANAGER_HALT,
1312                                 [1] = MANAGER_POWEROFF,
1313                                 [2] = MANAGER_REBOOT,
1314                                 [3] = MANAGER_KEXEC
1315                         };
1316
1317                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1318                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1319                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1320                                 manager_start_target(m, target_table[idx],
1321                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1322                                 break;
1323                         }
1324
1325                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1326                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1327                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1328                                 break;
1329                         }
1330
1331                         switch (sfsi.ssi_signo - SIGRTMIN) {
1332
1333                         case 20:
1334                                 log_debug("Enabling showing of status.");
1335                                 manager_set_show_status(m, true);
1336                                 break;
1337
1338                         case 21:
1339                                 log_debug("Disabling showing of status.");
1340                                 manager_set_show_status(m, false);
1341                                 break;
1342
1343                         case 22:
1344                                 log_set_max_level(LOG_DEBUG);
1345                                 log_notice("Setting log level to debug.");
1346                                 break;
1347
1348                         case 23:
1349                                 log_set_max_level(LOG_INFO);
1350                                 log_notice("Setting log level to info.");
1351                                 break;
1352
1353                         case 24:
1354                                 if (m->running_as == SYSTEMD_USER) {
1355                                         m->exit_code = MANAGER_EXIT;
1356                                         return 0;
1357                                 }
1358
1359                                 /* This is a nop on init */
1360                                 break;
1361
1362                         case 26:
1363                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1364                                 log_notice("Setting log target to journal-or-kmsg.");
1365                                 break;
1366
1367                         case 27:
1368                                 log_set_target(LOG_TARGET_CONSOLE);
1369                                 log_notice("Setting log target to console.");
1370                                 break;
1371
1372                         case 28:
1373                                 log_set_target(LOG_TARGET_KMSG);
1374                                 log_notice("Setting log target to kmsg.");
1375                                 break;
1376
1377                         case 29:
1378                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1379                                 log_notice("Setting log target to syslog-or-kmsg.");
1380                                 break;
1381
1382                         default:
1383                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1384                         }
1385                 }
1386                 }
1387         }
1388
1389         if (sigchld)
1390                 return manager_dispatch_sigchld(m);
1391
1392         return 0;
1393 }
1394
1395 static int process_event(Manager *m, struct epoll_event *ev) {
1396         int r;
1397         Watch *w;
1398
1399         assert(m);
1400         assert(ev);
1401
1402         assert_se(w = ev->data.ptr);
1403
1404         if (w->type == WATCH_INVALID)
1405                 return 0;
1406
1407         switch (w->type) {
1408
1409         case WATCH_SIGNAL:
1410
1411                 /* An incoming signal? */
1412                 if (ev->events != EPOLLIN)
1413                         return -EINVAL;
1414
1415                 if ((r = manager_process_signal_fd(m)) < 0)
1416                         return r;
1417
1418                 break;
1419
1420         case WATCH_NOTIFY:
1421
1422                 /* An incoming daemon notification event? */
1423                 if (ev->events != EPOLLIN)
1424                         return -EINVAL;
1425
1426                 if ((r = manager_process_notify_fd(m)) < 0)
1427                         return r;
1428
1429                 break;
1430
1431         case WATCH_FD:
1432
1433                 /* Some fd event, to be dispatched to the units */
1434                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1435                 break;
1436
1437         case WATCH_UNIT_TIMER:
1438         case WATCH_JOB_TIMER: {
1439                 uint64_t v;
1440                 ssize_t k;
1441
1442                 /* Some timer event, to be dispatched to the units */
1443                 k = read(w->fd, &v, sizeof(v));
1444                 if (k != sizeof(v)) {
1445
1446                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
1447                                 break;
1448
1449                         log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1450                         return k < 0 ? -errno : -EIO;
1451                 }
1452
1453                 if (w->type == WATCH_UNIT_TIMER)
1454                         UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1455                 else
1456                         job_timer_event(w->data.job, v, w);
1457                 break;
1458         }
1459
1460         case WATCH_MOUNT:
1461                 /* Some mount table change, intended for the mount subsystem */
1462                 mount_fd_event(m, ev->events);
1463                 break;
1464
1465         case WATCH_SWAP:
1466                 /* Some swap table change, intended for the swap subsystem */
1467                 swap_fd_event(m, ev->events);
1468                 break;
1469
1470         case WATCH_UDEV:
1471                 /* Some notification from udev, intended for the device subsystem */
1472                 device_fd_event(m, ev->events);
1473                 break;
1474
1475         case WATCH_DBUS_WATCH:
1476                 bus_watch_event(m, w, ev->events);
1477                 break;
1478
1479         case WATCH_DBUS_TIMEOUT:
1480                 bus_timeout_event(m, w, ev->events);
1481                 break;
1482
1483         case WATCH_TIME_CHANGE: {
1484                 Unit *u;
1485                 Iterator i;
1486
1487                 log_struct(LOG_INFO,
1488                            MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1489                            "MESSAGE=Time has been changed",
1490                            NULL);
1491
1492                 /* Restart the watch */
1493                 close_nointr_nofail(m->time_change_watch.fd);
1494                 watch_init(&m->time_change_watch);
1495                 manager_setup_time_change(m);
1496
1497                 HASHMAP_FOREACH(u, m->units, i) {
1498                         if (UNIT_VTABLE(u)->time_change)
1499                                 UNIT_VTABLE(u)->time_change(u);
1500                 }
1501
1502                 break;
1503         }
1504
1505         default:
1506                 log_error("event type=%i", w->type);
1507                 assert_not_reached("Unknown epoll event type.");
1508         }
1509
1510         return 0;
1511 }
1512
1513 int manager_loop(Manager *m) {
1514         int r;
1515
1516         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1517
1518         assert(m);
1519         m->exit_code = MANAGER_RUNNING;
1520
1521         /* Release the path cache */
1522         set_free_free(m->unit_path_cache);
1523         m->unit_path_cache = NULL;
1524
1525         manager_check_finished(m);
1526
1527         /* There might still be some zombies hanging around from
1528          * before we were exec()'ed. Leat's reap them */
1529         r = manager_dispatch_sigchld(m);
1530         if (r < 0)
1531                 return r;
1532
1533         while (m->exit_code == MANAGER_RUNNING) {
1534                 struct epoll_event event;
1535                 int n;
1536                 int wait_msec = -1;
1537
1538                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1539                         watchdog_ping();
1540
1541                 if (!ratelimit_test(&rl)) {
1542                         /* Yay, something is going seriously wrong, pause a little */
1543                         log_warning("Looping too fast. Throttling execution a little.");
1544                         sleep(1);
1545                         continue;
1546                 }
1547
1548                 if (manager_dispatch_load_queue(m) > 0)
1549                         continue;
1550
1551                 if (manager_dispatch_run_queue(m) > 0)
1552                         continue;
1553
1554                 if (bus_dispatch(m) > 0)
1555                         continue;
1556
1557                 if (manager_dispatch_cleanup_queue(m) > 0)
1558                         continue;
1559
1560                 if (manager_dispatch_gc_queue(m) > 0)
1561                         continue;
1562
1563                 if (manager_dispatch_dbus_queue(m) > 0)
1564                         continue;
1565
1566                 if (swap_dispatch_reload(m) > 0)
1567                         continue;
1568
1569                 /* Sleep for half the watchdog time */
1570                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1571                         wait_msec = (int) (m->runtime_watchdog / 2 / USEC_PER_MSEC);
1572                         if (wait_msec <= 0)
1573                                 wait_msec = 1;
1574                 } else
1575                         wait_msec = -1;
1576
1577                 n = epoll_wait(m->epoll_fd, &event, 1, wait_msec);
1578                 if (n < 0) {
1579
1580                         if (errno == EINTR)
1581                                 continue;
1582
1583                         return -errno;
1584                 } else if (n == 0)
1585                         continue;
1586
1587                 assert(n == 1);
1588
1589                 r = process_event(m, &event);
1590                 if (r < 0)
1591                         return r;
1592         }
1593
1594         return m->exit_code;
1595 }
1596
1597 int manager_load_unit_from_dbus_path(Manager *m, const char *s, DBusError *e, Unit **_u) {
1598         char *n;
1599         Unit *u;
1600         int r;
1601
1602         assert(m);
1603         assert(s);
1604         assert(_u);
1605
1606         if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1607                 return -EINVAL;
1608
1609         n = bus_path_unescape(s+31);
1610         if (!n)
1611                 return -ENOMEM;
1612
1613         r = manager_load_unit(m, n, NULL, e, &u);
1614         free(n);
1615
1616         if (r < 0)
1617                 return r;
1618
1619         *_u = u;
1620
1621         return 0;
1622 }
1623
1624 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1625         Job *j;
1626         unsigned id;
1627         int r;
1628
1629         assert(m);
1630         assert(s);
1631         assert(_j);
1632
1633         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1634                 return -EINVAL;
1635
1636         r = safe_atou(s + 30, &id);
1637         if (r < 0)
1638                 return r;
1639
1640         j = manager_get_job(m, id);
1641         if (!j)
1642                 return -ENOENT;
1643
1644         *_j = j;
1645
1646         return 0;
1647 }
1648
1649 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1650
1651 #ifdef HAVE_AUDIT
1652         char *p;
1653         int audit_fd;
1654
1655         audit_fd = get_audit_fd();
1656         if (audit_fd < 0)
1657                 return;
1658
1659         /* Don't generate audit events if the service was already
1660          * started and we're just deserializing */
1661         if (m->n_reloading > 0)
1662                 return;
1663
1664         if (m->running_as != SYSTEMD_SYSTEM)
1665                 return;
1666
1667         if (u->type != UNIT_SERVICE)
1668                 return;
1669
1670         if (!(p = unit_name_to_prefix_and_instance(u->id))) {
1671                 log_error("Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1672                 return;
1673         }
1674
1675         if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1676                 if (errno == EPERM) {
1677                         /* We aren't allowed to send audit messages?
1678                          * Then let's not retry again. */
1679                         close_audit_fd();
1680                 } else
1681                         log_warning("Failed to send audit message: %m");
1682         }
1683
1684         free(p);
1685 #endif
1686
1687 }
1688
1689 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1690         int fd = -1;
1691         union sockaddr_union sa;
1692         int n = 0;
1693         char *message = NULL;
1694
1695         /* Don't generate plymouth events if the service was already
1696          * started and we're just deserializing */
1697         if (m->n_reloading > 0)
1698                 return;
1699
1700         if (m->running_as != SYSTEMD_SYSTEM)
1701                 return;
1702
1703         if (u->type != UNIT_SERVICE &&
1704             u->type != UNIT_MOUNT &&
1705             u->type != UNIT_SWAP)
1706                 return;
1707
1708         /* We set SOCK_NONBLOCK here so that we rather drop the
1709          * message then wait for plymouth */
1710         if ((fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0)) < 0) {
1711                 log_error("socket() failed: %m");
1712                 return;
1713         }
1714
1715         zero(sa);
1716         sa.sa.sa_family = AF_UNIX;
1717         strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1718         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1719
1720                 if (errno != EPIPE &&
1721                     errno != EAGAIN &&
1722                     errno != ENOENT &&
1723                     errno != ECONNREFUSED &&
1724                     errno != ECONNRESET &&
1725                     errno != ECONNABORTED)
1726                         log_error("connect() failed: %m");
1727
1728                 goto finish;
1729         }
1730
1731         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1732                 log_oom();
1733                 goto finish;
1734         }
1735
1736         errno = 0;
1737         if (write(fd, message, n + 1) != n + 1) {
1738
1739                 if (errno != EPIPE &&
1740                     errno != EAGAIN &&
1741                     errno != ENOENT &&
1742                     errno != ECONNREFUSED &&
1743                     errno != ECONNRESET &&
1744                     errno != ECONNABORTED)
1745                         log_error("Failed to write Plymouth message: %m");
1746
1747                 goto finish;
1748         }
1749
1750 finish:
1751         if (fd >= 0)
1752                 close_nointr_nofail(fd);
1753
1754         free(message);
1755 }
1756
1757 void manager_dispatch_bus_name_owner_changed(
1758                 Manager *m,
1759                 const char *name,
1760                 const char* old_owner,
1761                 const char *new_owner) {
1762
1763         Unit *u;
1764
1765         assert(m);
1766         assert(name);
1767
1768         if (!(u = hashmap_get(m->watch_bus, name)))
1769                 return;
1770
1771         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1772 }
1773
1774 void manager_dispatch_bus_query_pid_done(
1775                 Manager *m,
1776                 const char *name,
1777                 pid_t pid) {
1778
1779         Unit *u;
1780
1781         assert(m);
1782         assert(name);
1783         assert(pid >= 1);
1784
1785         if (!(u = hashmap_get(m->watch_bus, name)))
1786                 return;
1787
1788         UNIT_VTABLE(u)->bus_query_pid_done(u, name, pid);
1789 }
1790
1791 int manager_open_serialization(Manager *m, FILE **_f) {
1792         char *path = NULL;
1793         mode_t saved_umask;
1794         int fd;
1795         FILE *f;
1796
1797         assert(_f);
1798
1799         if (m->running_as == SYSTEMD_SYSTEM)
1800                 asprintf(&path, "/run/systemd/dump-%lu-XXXXXX", (unsigned long) getpid());
1801         else
1802                 asprintf(&path, "/tmp/systemd-dump-%lu-XXXXXX", (unsigned long) getpid());
1803
1804         if (!path)
1805                 return -ENOMEM;
1806
1807         saved_umask = umask(0077);
1808         fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1809         umask(saved_umask);
1810
1811         if (fd < 0) {
1812                 free(path);
1813                 return -errno;
1814         }
1815
1816         unlink(path);
1817
1818         log_debug("Serializing state to %s", path);
1819         free(path);
1820
1821         f = fdopen(fd, "w+");
1822         if (!f)
1823                 return -errno;
1824
1825         *_f = f;
1826
1827         return 0;
1828 }
1829
1830 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool serialize_jobs) {
1831         Iterator i;
1832         Unit *u;
1833         const char *t;
1834         int r;
1835
1836         assert(m);
1837         assert(f);
1838         assert(fds);
1839
1840         m->n_reloading ++;
1841
1842         fprintf(f, "current-job-id=%i\n", m->current_job_id);
1843         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
1844         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
1845         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
1846
1847         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
1848         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
1849         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
1850         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
1851
1852         if (!in_initrd()) {
1853                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
1854                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
1855         }
1856
1857         fputc('\n', f);
1858
1859         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
1860                 if (u->id != t)
1861                         continue;
1862
1863                 if (!unit_can_serialize(u))
1864                         continue;
1865
1866                 /* Start marker */
1867                 fputs(u->id, f);
1868                 fputc('\n', f);
1869
1870                 if ((r = unit_serialize(u, f, fds, serialize_jobs)) < 0) {
1871                         m->n_reloading --;
1872                         return r;
1873                 }
1874         }
1875
1876         assert(m->n_reloading > 0);
1877         m->n_reloading --;
1878
1879         if (ferror(f))
1880                 return -EIO;
1881
1882         r = bus_fdset_add_all(m, fds);
1883         if (r < 0)
1884                 return r;
1885
1886         return 0;
1887 }
1888
1889 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
1890         int r = 0;
1891
1892         assert(m);
1893         assert(f);
1894
1895         log_debug("Deserializing state...");
1896
1897         m->n_reloading ++;
1898
1899         for (;;) {
1900                 char line[LINE_MAX], *l;
1901
1902                 if (!fgets(line, sizeof(line), f)) {
1903                         if (feof(f))
1904                                 r = 0;
1905                         else
1906                                 r = -errno;
1907
1908                         goto finish;
1909                 }
1910
1911                 char_array_0(line);
1912                 l = strstrip(line);
1913
1914                 if (l[0] == 0)
1915                         break;
1916
1917                 if (startswith(l, "current-job-id=")) {
1918                         uint32_t id;
1919
1920                         if (safe_atou32(l+15, &id) < 0)
1921                                 log_debug("Failed to parse current job id value %s", l+15);
1922                         else
1923                                 m->current_job_id = MAX(m->current_job_id, id);
1924                 } else if (startswith(l, "n-installed-jobs=")) {
1925                         uint32_t n;
1926
1927                         if (safe_atou32(l+17, &n) < 0)
1928                                 log_debug("Failed to parse installed jobs counter %s", l+17);
1929                         else
1930                                 m->n_installed_jobs += n;
1931                 } else if (startswith(l, "n-failed-jobs=")) {
1932                         uint32_t n;
1933
1934                         if (safe_atou32(l+14, &n) < 0)
1935                                 log_debug("Failed to parse failed jobs counter %s", l+14);
1936                         else
1937                                 m->n_failed_jobs += n;
1938                 } else if (startswith(l, "taint-usr=")) {
1939                         int b;
1940
1941                         if ((b = parse_boolean(l+10)) < 0)
1942                                 log_debug("Failed to parse taint /usr flag %s", l+10);
1943                         else
1944                                 m->taint_usr = m->taint_usr || b;
1945                 } else if (startswith(l, "firmware-timestamp="))
1946                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
1947                 else if (startswith(l, "loader-timestamp="))
1948                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
1949                 else if (startswith(l, "kernel-timestamp="))
1950                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
1951                 else if (startswith(l, "initrd-timestamp="))
1952                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
1953                 else if (startswith(l, "userspace-timestamp="))
1954                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
1955                 else if (startswith(l, "finish-timestamp="))
1956                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
1957                 else
1958                         log_debug("Unknown serialization item '%s'", l);
1959         }
1960
1961         for (;;) {
1962                 Unit *u;
1963                 char name[UNIT_NAME_MAX+2];
1964
1965                 /* Start marker */
1966                 if (!fgets(name, sizeof(name), f)) {
1967                         if (feof(f))
1968                                 r = 0;
1969                         else
1970                                 r = -errno;
1971
1972                         goto finish;
1973                 }
1974
1975                 char_array_0(name);
1976
1977                 if ((r = manager_load_unit(m, strstrip(name), NULL, NULL, &u)) < 0)
1978                         goto finish;
1979
1980                 r = unit_deserialize(u, f, fds);
1981                 if (r < 0)
1982                         goto finish;
1983         }
1984
1985 finish:
1986         if (ferror(f)) {
1987                 r = -EIO;
1988                 goto finish;
1989         }
1990
1991         assert(m->n_reloading > 0);
1992         m->n_reloading --;
1993
1994         return r;
1995 }
1996
1997 int manager_distribute_fds(Manager *m, FDSet *fds) {
1998         Unit *u;
1999         Iterator i;
2000         int r;
2001
2002         assert(m);
2003
2004         HASHMAP_FOREACH(u, m->units, i) {
2005
2006                 if (fdset_size(fds) <= 0)
2007                         break;
2008
2009                 if (UNIT_VTABLE(u)->distribute_fds) {
2010                         r = UNIT_VTABLE(u)->distribute_fds(u, fds);
2011                         if (r < 0)
2012                                 return r;
2013                 }
2014         }
2015
2016         return 0;
2017 }
2018
2019 int manager_reload(Manager *m) {
2020         int r, q;
2021         FILE *f;
2022         FDSet *fds;
2023
2024         assert(m);
2025
2026         r = manager_open_serialization(m, &f);
2027         if (r < 0)
2028                 return r;
2029
2030         m->n_reloading ++;
2031
2032         fds = fdset_new();
2033         if (!fds) {
2034                 m->n_reloading --;
2035                 r = -ENOMEM;
2036                 goto finish;
2037         }
2038
2039         r = manager_serialize(m, f, fds, true);
2040         if (r < 0) {
2041                 m->n_reloading --;
2042                 goto finish;
2043         }
2044
2045         if (fseeko(f, 0, SEEK_SET) < 0) {
2046                 m->n_reloading --;
2047                 r = -errno;
2048                 goto finish;
2049         }
2050
2051         /* From here on there is no way back. */
2052         manager_clear_jobs_and_units(m);
2053         manager_undo_generators(m);
2054         lookup_paths_free(&m->lookup_paths);
2055
2056         /* Find new unit paths */
2057         manager_run_generators(m);
2058
2059         q = lookup_paths_init(
2060                         &m->lookup_paths, m->running_as, true,
2061                         m->generator_unit_path,
2062                         m->generator_unit_path_early,
2063                         m->generator_unit_path_late);
2064         if (q < 0)
2065                 r = q;
2066
2067         manager_build_unit_path_cache(m);
2068
2069         /* First, enumerate what we can from all config files */
2070         q = manager_enumerate(m);
2071         if (q < 0)
2072                 r = q;
2073
2074         /* Second, deserialize our stored data */
2075         q = manager_deserialize(m, f, fds);
2076         if (q < 0)
2077                 r = q;
2078
2079         fclose(f);
2080         f = NULL;
2081
2082         /* Third, fire things up! */
2083         q = manager_coldplug(m);
2084         if (q < 0)
2085                 r = q;
2086
2087         assert(m->n_reloading > 0);
2088         m->n_reloading--;
2089
2090 finish:
2091         if (f)
2092                 fclose(f);
2093
2094         if (fds)
2095                 fdset_free(fds);
2096
2097         return r;
2098 }
2099
2100 bool manager_is_booting_or_shutting_down(Manager *m) {
2101         Unit *u;
2102
2103         assert(m);
2104
2105         /* Is the initial job still around? */
2106         if (manager_get_job(m, m->default_unit_job_id))
2107                 return true;
2108
2109         /* Is there a job for the shutdown target? */
2110         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2111         if (u)
2112                 return !!u->job;
2113
2114         return false;
2115 }
2116
2117 void manager_reset_failed(Manager *m) {
2118         Unit *u;
2119         Iterator i;
2120
2121         assert(m);
2122
2123         HASHMAP_FOREACH(u, m->units, i)
2124                 unit_reset_failed(u);
2125 }
2126
2127 bool manager_unit_pending_inactive(Manager *m, const char *name) {
2128         Unit *u;
2129
2130         assert(m);
2131         assert(name);
2132
2133         /* Returns true if the unit is inactive or going down */
2134         if (!(u = manager_get_unit(m, name)))
2135                 return true;
2136
2137         return unit_pending_inactive(u);
2138 }
2139
2140 void manager_check_finished(Manager *m) {
2141         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2142         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2143
2144         assert(m);
2145
2146         if (hashmap_size(m->jobs) > 0)
2147                 return;
2148
2149         /* Notify Type=idle units that we are done now */
2150         close_pipe(m->idle_pipe);
2151
2152         /* Turn off confirm spawn now */
2153         m->confirm_spawn = false;
2154
2155         if (dual_timestamp_is_set(&m->finish_timestamp))
2156                 return;
2157
2158         dual_timestamp_get(&m->finish_timestamp);
2159
2160         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2161
2162                 /* Note that m->kernel_usec.monotonic is always at 0,
2163                  * and m->firmware_usec.monotonic and
2164                  * m->loader_usec.monotonic should be considered
2165                  * negative values. */
2166
2167                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2168                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2169                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2170                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2171
2172                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2173
2174                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2175                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2176
2177                         if (!log_on_console())
2178                                 log_struct(LOG_INFO,
2179                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2180                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2181                                            "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2182                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2183                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2184                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2185                                            format_timespan(initrd, sizeof(initrd), initrd_usec),
2186                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2187                                            format_timespan(sum, sizeof(sum), total_usec),
2188                                            NULL);
2189                 } else {
2190                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2191                         initrd_usec = 0;
2192
2193                         if (!log_on_console())
2194                                 log_struct(LOG_INFO,
2195                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2196                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2197                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2198                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2199                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2200                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2201                                            format_timespan(sum, sizeof(sum), total_usec),
2202                                            NULL);
2203                 }
2204         } else {
2205                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2206                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2207
2208                 if (!log_on_console())
2209                         log_struct(LOG_INFO,
2210                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2211                                    "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2212                                    "MESSAGE=Startup finished in %s.",
2213                                    format_timespan(sum, sizeof(sum), total_usec),
2214                                    NULL);
2215         }
2216
2217         bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2218
2219         sd_notifyf(false,
2220                    "READY=1\nSTATUS=Startup finished in %s.",
2221                    format_timespan(sum, sizeof(sum), total_usec));
2222 }
2223
2224 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2225         char *p;
2226         int r;
2227
2228         assert(m);
2229         assert(generator);
2230         assert(name);
2231
2232         if (*generator)
2233                 return 0;
2234
2235         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2236
2237                 p = strappend("/run/systemd/", name);
2238                 if (!p)
2239                         return log_oom();
2240
2241                 r = mkdir_p_label(p, 0755);
2242                 if (r < 0) {
2243                         log_error("Failed to create generator directory: %s", strerror(-r));
2244                         free(p);
2245                         return r;
2246                 }
2247         } else {
2248                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2249                 if (!p)
2250                         return log_oom();
2251
2252                 if (!mkdtemp(p)) {
2253                         free(p);
2254                         log_error("Failed to create generator directory: %m");
2255                         return -errno;
2256                 }
2257         }
2258
2259         *generator = p;
2260         return 0;
2261 }
2262
2263 static void trim_generator_dir(Manager *m, char **generator) {
2264         assert(m);
2265         assert(generator);
2266
2267         if (!*generator)
2268                 return;
2269
2270         if (rmdir(*generator) >= 0) {
2271                 free(*generator);
2272                 *generator = NULL;
2273         }
2274
2275         return;
2276 }
2277
2278 void manager_run_generators(Manager *m) {
2279         DIR *d = NULL;
2280         const char *generator_path;
2281         const char *argv[5];
2282         mode_t u;
2283         int r;
2284
2285         assert(m);
2286
2287         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2288         d = opendir(generator_path);
2289         if (!d) {
2290                 if (errno == ENOENT)
2291                         return;
2292
2293                 log_error("Failed to enumerate generator directory: %m");
2294                 return;
2295         }
2296
2297         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2298         if (r < 0)
2299                 goto finish;
2300
2301         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2302         if (r < 0)
2303                 goto finish;
2304
2305         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2306         if (r < 0)
2307                 goto finish;
2308
2309         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2310         argv[1] = m->generator_unit_path;
2311         argv[2] = m->generator_unit_path_early;
2312         argv[3] = m->generator_unit_path_late;
2313         argv[4] = NULL;
2314
2315         u = umask(0022);
2316         execute_directory(generator_path, d, (char**) argv);
2317         umask(u);
2318
2319         trim_generator_dir(m, &m->generator_unit_path);
2320         trim_generator_dir(m, &m->generator_unit_path_early);
2321         trim_generator_dir(m, &m->generator_unit_path_late);
2322
2323 finish:
2324         if (d)
2325                 closedir(d);
2326 }
2327
2328 static void remove_generator_dir(Manager *m, char **generator) {
2329         assert(m);
2330         assert(generator);
2331
2332         if (!*generator)
2333                 return;
2334
2335         strv_remove(m->lookup_paths.unit_path, *generator);
2336         rm_rf(*generator, false, true, false);
2337
2338         free(*generator);
2339         *generator = NULL;
2340 }
2341
2342 void manager_undo_generators(Manager *m) {
2343         assert(m);
2344
2345         remove_generator_dir(m, &m->generator_unit_path);
2346         remove_generator_dir(m, &m->generator_unit_path_early);
2347         remove_generator_dir(m, &m->generator_unit_path_late);
2348 }
2349
2350 int manager_set_default_controllers(Manager *m, char **controllers) {
2351         char **l;
2352
2353         assert(m);
2354
2355         l = strv_copy(controllers);
2356         if (!l)
2357                 return -ENOMEM;
2358
2359         strv_free(m->default_controllers);
2360         m->default_controllers = l;
2361
2362         cg_shorten_controllers(m->default_controllers);
2363
2364         return 0;
2365 }
2366
2367 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2368         int i;
2369
2370         assert(m);
2371
2372         for (i = 0; i < RLIMIT_NLIMITS; i++) {
2373                 if (!default_rlimit[i])
2374                         continue;
2375
2376                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2377                 if (!m->rlimit[i])
2378                         return -ENOMEM;
2379         }
2380
2381         return 0;
2382 }
2383
2384 void manager_recheck_journal(Manager *m) {
2385         Unit *u;
2386
2387         assert(m);
2388
2389         if (m->running_as != SYSTEMD_SYSTEM)
2390                 return;
2391
2392         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2393         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2394                 log_close_journal();
2395                 return;
2396         }
2397
2398         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2399         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2400                 log_close_journal();
2401                 return;
2402         }
2403
2404         /* Hmm, OK, so the socket is fully up and the service is up
2405          * too, then let's make use of the thing. */
2406         log_open();
2407 }
2408
2409 void manager_set_show_status(Manager *m, bool b) {
2410         assert(m);
2411
2412         if (m->running_as != SYSTEMD_SYSTEM)
2413                 return;
2414
2415         m->show_status = b;
2416
2417         if (b)
2418                 touch("/run/systemd/show-status");
2419         else
2420                 unlink("/run/systemd/show-status");
2421 }
2422
2423 bool manager_get_show_status(Manager *m) {
2424         assert(m);
2425
2426         if (m->running_as != SYSTEMD_SYSTEM)
2427                 return false;
2428
2429         if (m->show_status)
2430                 return true;
2431
2432         /* If Plymouth is running make sure we show the status, so
2433          * that there's something nice to see when people press Esc */
2434
2435         return plymouth_running();
2436 }
2437
2438 void watch_init(Watch *w) {
2439         assert(w);
2440
2441         w->type = WATCH_INVALID;
2442         w->fd = -1;
2443 }