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