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