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