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