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         sa.un.sun_path[0] = '@';
 139         m->notify_socket = strdup(sa.un.sun_path);
 140         if (!m->notify_socket)
 141                 return log_oom();
 142
 143         log_debug("Using notification socket %s", m->notify_socket);
 144
 145         return 0;
 146 }
 147
 148 static int manager_watch_jobs_in_progress(Manager *m) {
 149         assert(m);
 150
 151         if (m->jobs_in_progress_event_source)
 152                 return 0;
 153
 154         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);
 155 }
 156
 157 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
 158
 159 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
 160         char *p = buffer;
 161
 162         assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
 163         assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
 164
 165         if (pos > 1) {
 166                 if (pos > 2)
 167                         p = mempset(p, ' ', pos-2);
 168                 p = stpcpy(p, ANSI_RED_ON);
 169                 *p++ = '*';
 170         }
 171
 172         if (pos > 0 && pos <= width) {
 173                 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
 174                 *p++ = '*';
 175         }
 176
 177         p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
 178
 179         if (pos < width) {
 180                 p = stpcpy(p, ANSI_RED_ON);
 181                 *p++ = '*';
 182                 if (pos < width-1)
 183                         p = mempset(p, ' ', width-1-pos);
 184                 strcpy(p, ANSI_HIGHLIGHT_OFF);
 185         }
 186 }
 187
 188 static void manager_print_jobs_in_progress(Manager *m) {
 189         _cleanup_free_ char *job_of_n = NULL;
 190         Iterator i;
 191         Job *j;
 192         unsigned counter = 0, print_nr;
 193         char cylon[6 + CYLON_BUFFER_EXTRA + 1];
 194         unsigned cylon_pos;
 195
 196         assert(m);
 197
 198         print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
 199
 200         HASHMAP_FOREACH(j, m->jobs, i)
 201                 if (j->state == JOB_RUNNING && counter++ == print_nr)
 202                         break;
 203
 204         /* m->n_running_jobs must be consistent with the contents of m->jobs,
 205          * so the above loop must have succeeded in finding j. */
 206         assert(counter == print_nr + 1);
 207         assert(j);
 208
 209         cylon_pos = m->jobs_in_progress_iteration % 14;
 210         if (cylon_pos >= 8)
 211                 cylon_pos = 14 - cylon_pos;
 212         draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
 213
 214         if (m->n_running_jobs > 1)
 215                 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
 216                         job_of_n = NULL;
 217
 218         manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
 219                               strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
 220
 221         m->jobs_in_progress_iteration++;
 222 }
 223
 224 static int manager_watch_idle_pipe(Manager *m) {
 225         int r;
 226
 227         assert(m);
 228
 229         if (m->idle_pipe_event_source)
 230                 return 0;
 231
 232         if (m->idle_pipe[2] < 0)
 233                 return 0;
 234
 235         r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
 236         if (r < 0) {
 237                 log_error("Failed to watch idle pipe: %s", strerror(-r));
 238                 return r;
 239         }
 240
 241         return 0;
 242 }
 243
 244 static void manager_close_idle_pipe(Manager *m) {
 245         assert(m);
 246
 247         close_pipe(m->idle_pipe);
 248         close_pipe(m->idle_pipe + 2);
 249 }
 250
 251 static int manager_setup_time_change(Manager *m) {
 252         int r;
 253
 254         /* We only care for the cancellation event, hence we set the
 255          * timeout to the latest possible value. */
 256         struct itimerspec its = {
 257                 .it_value.tv_sec = TIME_T_MAX,
 258         };
 259
 260         assert(m);
 261         assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
 262
 263         /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
 264          * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
 265
 266         m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
 267         if (m->time_change_fd < 0) {
 268                 log_error("Failed to create timerfd: %m");
 269                 return -errno;
 270         }
 271
 272         if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
 273                 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
 274                 close_nointr_nofail(m->time_change_fd);
 275                 m->time_change_fd = -1;
 276                 return 0;
 277         }
 278
 279         r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
 280         if (r < 0) {
 281                 log_error("Failed to create time change event source: %s", strerror(-r));
 282                 return r;
 283         }
 284
 285         log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
 286
 287         return 0;
 288 }
 289
 290 static int enable_special_signals(Manager *m) {
 291         _cleanup_close_ int fd = -1;
 292
 293         assert(m);
 294
 295         /* Enable that we get SIGINT on control-alt-del. In containers
 296          * this will fail with EPERM (older) or EINVAL (newer), so
 297          * ignore that. */
 298         if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
 299                 log_warning("Failed to enable ctrl-alt-del handling: %m");
 300
 301         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 302         if (fd < 0) {
 303                 /* Support systems without virtual console */
 304                 if (fd != -ENOENT)
 305                         log_warning("Failed to open /dev/tty0: %m");
 306         } else {
 307                 /* Enable that we get SIGWINCH on kbrequest */
 308                 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
 309                         log_warning("Failed to enable kbrequest handling: %m");
 310         }
 311
 312         return 0;
 313 }
 314
 315 static int manager_setup_signals(Manager *m) {
 316         struct sigaction sa = {
 317                 .sa_handler = SIG_DFL,
 318                 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
 319         };
 320         sigset_t mask;
 321         int r;
 322
 323         assert(m);
 324
 325         /* We are not interested in SIGSTOP and friends. */
 326         assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
 327
 328         assert_se(sigemptyset(&mask) == 0);
 329
 330         sigset_add_many(&mask,
 331                         SIGCHLD,     /* Child died */
 332                         SIGTERM,     /* Reexecute daemon */
 333                         SIGHUP,      /* Reload configuration */
 334                         SIGUSR1,     /* systemd/upstart: reconnect to D-Bus */
 335                         SIGUSR2,     /* systemd: dump status */
 336                         SIGINT,      /* Kernel sends us this on control-alt-del */
 337                         SIGWINCH,    /* Kernel sends us this on kbrequest (alt-arrowup) */
 338                         SIGPWR,      /* Some kernel drivers and upsd send us this on power failure */
 339                         SIGRTMIN+0,  /* systemd: start default.target */
 340                         SIGRTMIN+1,  /* systemd: isolate rescue.target */
 341                         SIGRTMIN+2,  /* systemd: isolate emergency.target */
 342                         SIGRTMIN+3,  /* systemd: start halt.target */
 343                         SIGRTMIN+4,  /* systemd: start poweroff.target */
 344                         SIGRTMIN+5,  /* systemd: start reboot.target */
 345                         SIGRTMIN+6,  /* systemd: start kexec.target */
 346                         SIGRTMIN+13, /* systemd: Immediate halt */
 347                         SIGRTMIN+14, /* systemd: Immediate poweroff */
 348                         SIGRTMIN+15, /* systemd: Immediate reboot */
 349                         SIGRTMIN+16, /* systemd: Immediate kexec */
 350                         SIGRTMIN+20, /* systemd: enable status messages */
 351                         SIGRTMIN+21, /* systemd: disable status messages */
 352                         SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
 353                         SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
 354                         SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
 355                         SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
 356                         SIGRTMIN+27, /* systemd: set log target to console */
 357                         SIGRTMIN+28, /* systemd: set log target to kmsg */
 358                         SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
 359                         -1);
 360         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
 361
 362         m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 363         if (m->signal_fd < 0)
 364                 return -errno;
 365
 366         r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
 367         if (r < 0)
 368                 return r;
 369
 370         /* Process signals a bit earlier than the rest of things */
 371         r = sd_event_source_set_priority(m->signal_event_source, -5);
 372         if (r < 0)
 373                 return r;
 374
 375         if (m->running_as == SYSTEMD_SYSTEM)
 376                 return enable_special_signals(m);
 377
 378         return 0;
 379 }
 380
 381 static int manager_default_environment(Manager *m) {
 382         assert(m);
 383
 384         if (m->running_as == SYSTEMD_SYSTEM) {
 385                 /* The system manager always starts with a clean
 386                  * environment for its children. It does not import
 387                  * the kernel or the parents exported variables.
 388                  *
 389                  * The initial passed environ is untouched to keep
 390                  * /proc/self/environ valid; it is used for tagging
 391                  * the init process inside containers. */
 392                 m->environment = strv_new("PATH=" DEFAULT_PATH,
 393                                           NULL);
 394
 395                 /* Import locale variables LC_*= from configuration */
 396                 locale_setup(&m->environment);
 397         } else
 398                 /* The user manager passes its own environment
 399                  * along to its children. */
 400                 m->environment = strv_copy(environ);
 401
 402         if (!m->environment)
 403                 return -ENOMEM;
 404
 405         strv_sort(m->environment);
 406
 407         return 0;
 408 }
 409
 410 static int manager_setup_kdbus(Manager *m) {
 411         _cleanup_free_ char *p = NULL;
 412
 413         assert(m);
 414
 415 #ifdef ENABLE_KDBUS
 416         if (m->kdbus_fd >= 0)
 417                 return 0;
 418
 419         /* If there's already a bus address set, don't set up kdbus */
 420         if (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"))
 421                 return 0;
 422
 423         m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", &p);
 424         if (m->kdbus_fd < 0) {
 425                 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
 426                 return m->kdbus_fd;
 427         }
 428
 429         log_debug("Successfully set up kdbus on %s", p);
 430
 431         /* Create the namespace directory here, so that the contents
 432          * of that directory is not visible to non-root users. This is
 433          * necessary to ensure that users cannot get access to busses
 434          * of virtualized users when no UID namespacing is used. */
 435         mkdir_p_label("/dev/kdbus/ns", 0700);
 436 #endif
 437
 438         return 0;
 439 }
 440
 441 static int manager_connect_bus(Manager *m, bool reexecuting) {
 442         bool try_bus_connect;
 443
 444         assert(m);
 445
 446         try_bus_connect =
 447                 m->kdbus_fd >= 0 ||
 448                 reexecuting ||
 449                 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
 450
 451         /* Try to connect to the busses, if possible. */
 452         return bus_init(m, try_bus_connect);
 453 }
 454
 455 int manager_new(SystemdRunningAs running_as, Manager **_m) {
 456         Manager *m;
 457         int r;
 458
 459         assert(_m);
 460         assert(running_as >= 0);
 461         assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
 462
 463         m = new0(Manager, 1);
 464         if (!m)
 465                 return -ENOMEM;
 466
 467 #ifdef ENABLE_EFI
 468         if (detect_container(NULL) <= 0)
 469                 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
 470 #endif
 471
 472         m->running_as = running_as;
 473         m->exit_code = _MANAGER_EXIT_CODE_INVALID;
 474
 475         m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
 476
 477         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;
 478         m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
 479
 480         r = manager_default_environment(m);
 481         if (r < 0)
 482                 goto fail;
 483
 484         r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
 485         if (r < 0)
 486                 goto fail;
 487
 488         r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
 489         if (r < 0)
 490                 goto fail;
 491
 492         r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
 493         if (r < 0)
 494                 goto fail;
 495
 496         r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
 497         if (r < 0)
 498                 goto fail;
 499
 500         r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
 501         if (r < 0)
 502                 goto fail;
 503
 504         r = sd_event_default(&m->event);
 505         if (r < 0)
 506                 goto fail;
 507
 508         r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
 509         if (r < 0)
 510                 goto fail;
 511
 512         r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
 513         if (r < 0)
 514                 goto fail;
 515
 516         r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
 517         if (r < 0)
 518                 goto fail;
 519
 520         r = manager_setup_signals(m);
 521         if (r < 0)
 522                 goto fail;
 523
 524         r = manager_setup_cgroup(m);
 525         if (r < 0)
 526                 goto fail;
 527
 528         r = manager_setup_notify(m);
 529         if (r < 0)
 530                 goto fail;
 531
 532         r = manager_setup_time_change(m);
 533         if (r < 0)
 534                 goto fail;
 535
 536         m->udev = udev_new();
 537         if (!m->udev) {
 538                 r = -ENOMEM;
 539                 goto fail;
 540         }
 541
 542         m->taint_usr = dir_is_empty("/usr") > 0;
 543
 544         *_m = m;
 545         return 0;
 546
 547 fail:
 548         manager_free(m);
 549         return r;
 550 }
 551
 552 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
 553         Unit *u;
 554         unsigned n = 0;
 555
 556         assert(m);
 557
 558         while ((u = m->cleanup_queue)) {
 559                 assert(u->in_cleanup_queue);
 560
 561                 unit_free(u);
 562                 n++;
 563         }
 564
 565         return n;
 566 }
 567
 568 enum {
 569         GC_OFFSET_IN_PATH,  /* This one is on the path we were traveling */
 570         GC_OFFSET_UNSURE,   /* No clue */
 571         GC_OFFSET_GOOD,     /* We still need this unit */
 572         GC_OFFSET_BAD,      /* We don't need this unit anymore */
 573         _GC_OFFSET_MAX
 574 };
 575
 576 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
 577         Iterator i;
 578         Unit *other;
 579         bool is_bad;
 580
 581         assert(u);
 582
 583         if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
 584             u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 585             u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
 586                 return;
 587
 588         if (u->in_cleanup_queue)
 589                 goto bad;
 590
 591         if (unit_check_gc(u))
 592                 goto good;
 593
 594         u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
 595
 596         is_bad = true;
 597
 598         SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
 599                 unit_gc_sweep(other, gc_marker);
 600
 601                 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
 602                         goto good;
 603
 604                 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
 605                         is_bad = false;
 606         }
 607
 608         if (is_bad)
 609                 goto bad;
 610
 611         /* We were unable to find anything out about this entry, so
 612          * let's investigate it later */
 613         u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
 614         unit_add_to_gc_queue(u);
 615         return;
 616
 617 bad:
 618         /* We definitely know that this one is not useful anymore, so
 619          * let's mark it for deletion */
 620         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 621         unit_add_to_cleanup_queue(u);
 622         return;
 623
 624 good:
 625         u->gc_marker = gc_marker + GC_OFFSET_GOOD;
 626 }
 627
 628 static unsigned manager_dispatch_gc_queue(Manager *m) {
 629         Unit *u;
 630         unsigned n = 0;
 631         unsigned gc_marker;
 632
 633         assert(m);
 634
 635         /* log_debug("Running GC..."); */
 636
 637         m->gc_marker += _GC_OFFSET_MAX;
 638         if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
 639                 m->gc_marker = 1;
 640
 641         gc_marker = m->gc_marker;
 642
 643         while ((u = m->gc_queue)) {
 644                 assert(u->in_gc_queue);
 645
 646                 unit_gc_sweep(u, gc_marker);
 647
 648                 LIST_REMOVE(gc_queue, m->gc_queue, u);
 649                 u->in_gc_queue = false;
 650
 651                 n++;
 652
 653                 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 654                     u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
 655                         log_debug_unit(u->id, "Collecting %s", u->id);
 656                         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 657                         unit_add_to_cleanup_queue(u);
 658                 }
 659         }
 660
 661         m->n_in_gc_queue = 0;
 662
 663         return n;
 664 }
 665
 666 static void manager_clear_jobs_and_units(Manager *m) {
 667         Unit *u;
 668
 669         assert(m);
 670
 671         while ((u = hashmap_first(m->units)))
 672                 unit_free(u);
 673
 674         manager_dispatch_cleanup_queue(m);
 675
 676         assert(!m->load_queue);
 677         assert(!m->run_queue);
 678         assert(!m->dbus_unit_queue);
 679         assert(!m->dbus_job_queue);
 680         assert(!m->cleanup_queue);
 681         assert(!m->gc_queue);
 682
 683         assert(hashmap_isempty(m->jobs));
 684         assert(hashmap_isempty(m->units));
 685
 686         m->n_on_console = 0;
 687         m->n_running_jobs = 0;
 688 }
 689
 690 void manager_free(Manager *m) {
 691         UnitType c;
 692         int i;
 693
 694         assert(m);
 695
 696         manager_clear_jobs_and_units(m);
 697
 698         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 699                 if (unit_vtable[c]->shutdown)
 700                         unit_vtable[c]->shutdown(m);
 701
 702         /* If we reexecute ourselves, we keep the root cgroup
 703          * around */
 704         manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
 705
 706         manager_undo_generators(m);
 707
 708         bus_done(m);
 709
 710         hashmap_free(m->units);
 711         hashmap_free(m->jobs);
 712         hashmap_free(m->watch_pids);
 713         hashmap_free(m->watch_bus);
 714
 715         sd_event_source_unref(m->signal_event_source);
 716         sd_event_source_unref(m->notify_event_source);
 717         sd_event_source_unref(m->time_change_event_source);
 718         sd_event_source_unref(m->jobs_in_progress_event_source);
 719         sd_event_source_unref(m->idle_pipe_event_source);
 720         sd_event_source_unref(m->run_queue_event_source);
 721
 722         if (m->signal_fd >= 0)
 723                 close_nointr_nofail(m->signal_fd);
 724         if (m->notify_fd >= 0)
 725                 close_nointr_nofail(m->notify_fd);
 726         if (m->time_change_fd >= 0)
 727                 close_nointr_nofail(m->time_change_fd);
 728         if (m->kdbus_fd >= 0)
 729                 close_nointr_nofail(m->kdbus_fd);
 730
 731         manager_close_idle_pipe(m);
 732
 733         udev_unref(m->udev);
 734         sd_event_unref(m->event);
 735
 736         free(m->notify_socket);
 737
 738         lookup_paths_free(&m->lookup_paths);
 739         strv_free(m->environment);
 740
 741         hashmap_free(m->cgroup_unit);
 742         set_free_free(m->unit_path_cache);
 743
 744         free(m->switch_root);
 745         free(m->switch_root_init);
 746
 747         for (i = 0; i < RLIMIT_NLIMITS; i++)
 748                 free(m->rlimit[i]);
 749
 750         assert(hashmap_isempty(m->units_requiring_mounts_for));
 751         hashmap_free(m->units_requiring_mounts_for);
 752
 753         free(m);
 754 }
 755
 756 int manager_enumerate(Manager *m) {
 757         int r = 0, q;
 758         UnitType c;
 759
 760         assert(m);
 761
 762         /* Let's ask every type to load all units from disk/kernel
 763          * that it might know */
 764         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 765                 if (unit_vtable[c]->enumerate) {
 766                         q = unit_vtable[c]->enumerate(m);
 767                         if (q < 0)
 768                                 r = q;
 769                 }
 770
 771         manager_dispatch_load_queue(m);
 772         return r;
 773 }
 774
 775 static int manager_coldplug(Manager *m) {
 776         int r = 0, q;
 777         Iterator i;
 778         Unit *u;
 779         char *k;
 780
 781         assert(m);
 782
 783         /* Then, let's set up their initial state. */
 784         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 785
 786                 /* ignore aliases */
 787                 if (u->id != k)
 788                         continue;
 789
 790                 if ((q = unit_coldplug(u)) < 0)
 791                         r = q;
 792         }
 793
 794         return r;
 795 }
 796
 797 static void manager_build_unit_path_cache(Manager *m) {
 798         char **i;
 799         _cleanup_free_ DIR *d = NULL;
 800         int r;
 801
 802         assert(m);
 803
 804         set_free_free(m->unit_path_cache);
 805
 806         m->unit_path_cache = set_new(string_hash_func, string_compare_func);
 807         if (!m->unit_path_cache) {
 808                 log_error("Failed to allocate unit path cache.");
 809                 return;
 810         }
 811
 812         /* This simply builds a list of files we know exist, so that
 813          * we don't always have to go to disk */
 814
 815         STRV_FOREACH(i, m->lookup_paths.unit_path) {
 816                 struct dirent *de;
 817
 818                 d = opendir(*i);
 819                 if (!d) {
 820                         if (errno != ENOENT)
 821                                 log_error("Failed to open directory %s: %m", *i);
 822                         continue;
 823                 }
 824
 825                 while ((de = readdir(d))) {
 826                         char *p;
 827
 828                         if (ignore_file(de->d_name))
 829                                 continue;
 830
 831                         p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
 832                         if (!p) {
 833                                 r = -ENOMEM;
 834                                 goto fail;
 835                         }
 836
 837                         r = set_consume(m->unit_path_cache, p);
 838                         if (r < 0)
 839                                 goto fail;
 840                 }
 841
 842                 closedir(d);
 843                 d = NULL;
 844         }
 845
 846         return;
 847
 848 fail:
 849         log_error("Failed to build unit path cache: %s", strerror(-r));
 850
 851         set_free_free(m->unit_path_cache);
 852         m->unit_path_cache = NULL;
 853 }
 854
 855
 856 static int manager_distribute_fds(Manager *m, FDSet *fds) {
 857         Unit *u;
 858         Iterator i;
 859         int r;
 860
 861         assert(m);
 862
 863         HASHMAP_FOREACH(u, m->units, i) {
 864
 865                 if (fdset_size(fds) <= 0)
 866                         break;
 867
 868                 if (UNIT_VTABLE(u)->distribute_fds) {
 869                         r = UNIT_VTABLE(u)->distribute_fds(u, fds);
 870                         if (r < 0)
 871                                 return r;
 872                 }
 873         }
 874
 875         return 0;
 876 }
 877
 878 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
 879         int r, q;
 880
 881         assert(m);
 882
 883         dual_timestamp_get(&m->generators_start_timestamp);
 884         manager_run_generators(m);
 885         dual_timestamp_get(&m->generators_finish_timestamp);
 886
 887         r = lookup_paths_init(
 888                         &m->lookup_paths, m->running_as, true,
 889                         m->generator_unit_path,
 890                         m->generator_unit_path_early,
 891                         m->generator_unit_path_late);
 892         if (r < 0)
 893                 return r;
 894
 895         manager_build_unit_path_cache(m);
 896
 897         /* If we will deserialize make sure that during enumeration
 898          * this is already known, so we increase the counter here
 899          * already */
 900         if (serialization)
 901                 m->n_reloading ++;
 902
 903         /* First, enumerate what we can from all config files */
 904         dual_timestamp_get(&m->units_load_start_timestamp);
 905         r = manager_enumerate(m);
 906         dual_timestamp_get(&m->units_load_finish_timestamp);
 907
 908         /* Second, deserialize if there is something to deserialize */
 909         if (serialization) {
 910                 q = manager_deserialize(m, serialization, fds);
 911                 if (q < 0)
 912                         r = q;
 913         }
 914
 915         /* Any fds left? Find some unit which wants them. This is
 916          * useful to allow container managers to pass some file
 917          * descriptors to us pre-initialized. This enables
 918          * socket-based activation of entire containers. */
 919         if (fdset_size(fds) > 0) {
 920                 q = manager_distribute_fds(m, fds);
 921                 if (q < 0)
 922                         r = q;
 923         }
 924
 925         /* We might have deserialized the kdbus control fd, but if we
 926          * didn't, then let's create the bus now. */
 927         manager_setup_kdbus(m);
 928         manager_connect_bus(m, !!serialization);
 929
 930         /* Third, fire things up! */
 931         q = manager_coldplug(m);
 932         if (q < 0)
 933                 r = q;
 934
 935         if (serialization) {
 936                 assert(m->n_reloading > 0);
 937                 m->n_reloading --;
 938
 939                 /* Let's wait for the UnitNew/JobNew messages being
 940                  * sent, before we notify that the reload is
 941                  * finished */
 942                 m->send_reloading_done = true;
 943         }
 944
 945         return r;
 946 }
 947
 948 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
 949         int r;
 950         Transaction *tr;
 951
 952         assert(m);
 953         assert(type < _JOB_TYPE_MAX);
 954         assert(unit);
 955         assert(mode < _JOB_MODE_MAX);
 956
 957         if (mode == JOB_ISOLATE && type != JOB_START) {
 958                 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
 959                 return -EINVAL;
 960         }
 961
 962         if (mode == JOB_ISOLATE && !unit->allow_isolate) {
 963                 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
 964                 return -EPERM;
 965         }
 966
 967         log_debug_unit(unit->id,
 968                        "Trying to enqueue job %s/%s/%s", unit->id,
 969                        job_type_to_string(type), job_mode_to_string(mode));
 970
 971         job_type_collapse(&type, unit);
 972
 973         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
 974         if (!tr)
 975                 return -ENOMEM;
 976
 977         r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
 978                                                  mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
 979                                                  mode == JOB_IGNORE_DEPENDENCIES, e);
 980         if (r < 0)
 981                 goto tr_abort;
 982
 983         if (mode == JOB_ISOLATE) {
 984                 r = transaction_add_isolate_jobs(tr, m);
 985                 if (r < 0)
 986                         goto tr_abort;
 987         }
 988
 989         r = transaction_activate(tr, m, mode, e);
 990         if (r < 0)
 991                 goto tr_abort;
 992
 993         log_debug_unit(unit->id,
 994                        "Enqueued job %s/%s as %u", unit->id,
 995                        job_type_to_string(type), (unsigned) tr->anchor_job->id);
 996
 997         if (_ret)
 998                 *_ret = tr->anchor_job;
 999
1000         transaction_free(tr);
1001         return 0;
1002
1003 tr_abort:
1004         transaction_abort(tr);
1005         transaction_free(tr);
1006         return r;
1007 }
1008
1009 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1010         Unit *unit;
1011         int r;
1012
1013         assert(m);
1014         assert(type < _JOB_TYPE_MAX);
1015         assert(name);
1016         assert(mode < _JOB_MODE_MAX);
1017
1018         r = manager_load_unit(m, name, NULL, NULL, &unit);
1019         if (r < 0)
1020                 return r;
1021
1022         return manager_add_job(m, type, unit, mode, override, e, _ret);
1023 }
1024
1025 Job *manager_get_job(Manager *m, uint32_t id) {
1026         assert(m);
1027
1028         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1029 }
1030
1031 Unit *manager_get_unit(Manager *m, const char *name) {
1032         assert(m);
1033         assert(name);
1034
1035         return hashmap_get(m->units, name);
1036 }
1037
1038 unsigned manager_dispatch_load_queue(Manager *m) {
1039         Unit *u;
1040         unsigned n = 0;
1041
1042         assert(m);
1043
1044         /* Make sure we are not run recursively */
1045         if (m->dispatching_load_queue)
1046                 return 0;
1047
1048         m->dispatching_load_queue = true;
1049
1050         /* Dispatches the load queue. Takes a unit from the queue and
1051          * tries to load its data until the queue is empty */
1052
1053         while ((u = m->load_queue)) {
1054                 assert(u->in_load_queue);
1055
1056                 unit_load(u);
1057                 n++;
1058         }
1059
1060         m->dispatching_load_queue = false;
1061         return n;
1062 }
1063
1064 int manager_load_unit_prepare(
1065                 Manager *m,
1066                 const char *name,
1067                 const char *path,
1068                 sd_bus_error *e,
1069                 Unit **_ret) {
1070
1071         Unit *ret;
1072         UnitType t;
1073         int r;
1074
1075         assert(m);
1076         assert(name || path);
1077
1078         /* This will prepare the unit for loading, but not actually
1079          * load anything from disk. */
1080
1081         if (path && !is_path(path))
1082                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1083
1084         if (!name)
1085                 name = basename(path);
1086
1087         t = unit_name_to_type(name);
1088
1089         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false))
1090                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1091
1092         ret = manager_get_unit(m, name);
1093         if (ret) {
1094                 *_ret = ret;
1095                 return 1;
1096         }
1097
1098         ret = unit_new(m, unit_vtable[t]->object_size);
1099         if (!ret)
1100                 return -ENOMEM;
1101
1102         if (path) {
1103                 ret->fragment_path = strdup(path);
1104                 if (!ret->fragment_path) {
1105                         unit_free(ret);
1106                         return -ENOMEM;
1107                 }
1108         }
1109
1110         r = unit_add_name(ret, name);
1111         if (r < 0) {
1112                 unit_free(ret);
1113                 return r;
1114         }
1115
1116         unit_add_to_load_queue(ret);
1117         unit_add_to_dbus_queue(ret);
1118         unit_add_to_gc_queue(ret);
1119
1120         if (_ret)
1121                 *_ret = ret;
1122
1123         return 0;
1124 }
1125
1126 int manager_load_unit(
1127                 Manager *m,
1128                 const char *name,
1129                 const char *path,
1130                 sd_bus_error *e,
1131                 Unit **_ret) {
1132
1133         int r;
1134
1135         assert(m);
1136
1137         /* This will load the service information files, but not actually
1138          * start any services or anything. */
1139
1140         r = manager_load_unit_prepare(m, name, path, e, _ret);
1141         if (r != 0)
1142                 return r;
1143
1144         manager_dispatch_load_queue(m);
1145
1146         if (_ret)
1147                 *_ret = unit_follow_merge(*_ret);
1148
1149         return 0;
1150 }
1151
1152 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1153         Iterator i;
1154         Job *j;
1155
1156         assert(s);
1157         assert(f);
1158
1159         HASHMAP_FOREACH(j, s->jobs, i)
1160                 job_dump(j, f, prefix);
1161 }
1162
1163 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1164         Iterator i;
1165         Unit *u;
1166         const char *t;
1167
1168         assert(s);
1169         assert(f);
1170
1171         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1172                 if (u->id == t)
1173                         unit_dump(u, f, prefix);
1174 }
1175
1176 void manager_clear_jobs(Manager *m) {
1177         Job *j;
1178
1179         assert(m);
1180
1181         while ((j = hashmap_first(m->jobs)))
1182                 /* No need to recurse. We're cancelling all jobs. */
1183                 job_finish_and_invalidate(j, JOB_CANCELED, false);
1184 }
1185
1186 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1187         Manager *m = userdata;
1188         Job *j;
1189
1190         assert(source);
1191         assert(m);
1192
1193         while ((j = m->run_queue)) {
1194                 assert(j->installed);
1195                 assert(j->in_run_queue);
1196
1197                 job_run_and_invalidate(j);
1198         }
1199
1200         if (m->n_running_jobs > 0)
1201                 manager_watch_jobs_in_progress(m);
1202
1203         if (m->n_on_console > 0)
1204                 manager_watch_idle_pipe(m);
1205
1206         return 1;
1207 }
1208
1209 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1210         Job *j;
1211         Unit *u;
1212         unsigned n = 0;
1213
1214         assert(m);
1215
1216         if (m->dispatching_dbus_queue)
1217                 return 0;
1218
1219         m->dispatching_dbus_queue = true;
1220
1221         while ((u = m->dbus_unit_queue)) {
1222                 assert(u->in_dbus_queue);
1223
1224                 bus_unit_send_change_signal(u);
1225                 n++;
1226         }
1227
1228         while ((j = m->dbus_job_queue)) {
1229                 assert(j->in_dbus_queue);
1230
1231                 bus_job_send_change_signal(j);
1232                 n++;
1233         }
1234
1235         m->dispatching_dbus_queue = false;
1236
1237         if (m->send_reloading_done) {
1238                 m->send_reloading_done = false;
1239
1240                 bus_manager_send_reloading(m, false);
1241         }
1242
1243         if (m->queued_message)
1244                 bus_send_queued_message(m);
1245
1246         return n;
1247 }
1248
1249 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1250         Manager *m = userdata;
1251         ssize_t n;
1252
1253         assert(m);
1254         assert(m->notify_fd == fd);
1255
1256         if (revents != EPOLLIN) {
1257                 log_warning("Got unexpected poll event for notify fd.");
1258                 return 0;
1259         }
1260
1261         for (;;) {
1262                 char buf[4096];
1263                 struct iovec iovec = {
1264                         .iov_base = buf,
1265                         .iov_len = sizeof(buf)-1,
1266                 };
1267
1268                 union {
1269                         struct cmsghdr cmsghdr;
1270                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1271                 } control = {};
1272
1273                 struct msghdr msghdr = {
1274                         .msg_iov = &iovec,
1275                         .msg_iovlen = 1,
1276                         .msg_control = &control,
1277                         .msg_controllen = sizeof(control),
1278                 };
1279                 struct ucred *ucred;
1280                 Unit *u;
1281                 _cleanup_strv_free_ char **tags = NULL;
1282
1283                 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1284                 if (n <= 0) {
1285                         if (n == 0)
1286                                 return -EIO;
1287
1288                         if (errno == EAGAIN || errno == EINTR)
1289                                 break;
1290
1291                         return -errno;
1292                 }
1293
1294                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1295                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
1296                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1297                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1298                         log_warning("Received notify message without credentials. Ignoring.");
1299                         continue;
1300                 }
1301
1302                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1303
1304                 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1305                 if (!u) {
1306                         u = manager_get_unit_by_pid(m, ucred->pid);
1307                         if (!u) {
1308                                 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1309                                 continue;
1310                         }
1311                 }
1312
1313                 assert((size_t) n < sizeof(buf));
1314                 buf[n] = 0;
1315                 tags = strv_split(buf, "\n\r");
1316                 if (!tags)
1317                         return log_oom();
1318
1319                 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1320
1321                 if (UNIT_VTABLE(u)->notify_message)
1322                         UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1323         }
1324
1325         return 0;
1326 }
1327
1328 static int manager_dispatch_sigchld(Manager *m) {
1329         assert(m);
1330
1331         for (;;) {
1332                 siginfo_t si = {};
1333                 Unit *u;
1334                 int r;
1335
1336                 /* First we call waitd() for a PID and do not reap the
1337                  * zombie. That way we can still access /proc/$PID for
1338                  * it while it is a zombie. */
1339                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1340
1341                         if (errno == ECHILD)
1342                                 break;
1343
1344                         if (errno == EINTR)
1345                                 continue;
1346
1347                         return -errno;
1348                 }
1349
1350                 if (si.si_pid <= 0)
1351                         break;
1352
1353                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1354                         _cleanup_free_ char *name = NULL;
1355
1356                         get_process_comm(si.si_pid, &name);
1357                         log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1358                 }
1359
1360                 /* Let's flush any message the dying child might still
1361                  * have queued for us. This ensures that the process
1362                  * still exists in /proc so that we can figure out
1363                  * which cgroup and hence unit it belongs to. */
1364                 r = manager_dispatch_notify_fd(m->notify_event_source, m->notify_fd, EPOLLIN, m);
1365                 if (r < 0)
1366                         return r;
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 }