src/core/manager.c

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