src/core/manager.c

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