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