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