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