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