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