src/core/manager.c

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