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