src/core/manager.c

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