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