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