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         zero(its);
 152
 153         its.it_value.tv_sec = JOBS_IN_PROGRESS_WAIT_SEC;
 154         its.it_interval.tv_sec = JOBS_IN_PROGRESS_PERIOD_SEC;
 155
 156         if (timerfd_settime(m->jobs_in_progress_watch.fd, 0, &its, NULL) < 0)
 157                 return -errno;
 158
 159         return 0;
 160 }
 161
 162 static int manager_watch_jobs_in_progress(Manager *m) {
 163         struct epoll_event ev;
 164         int r;
 165
 166         assert(m);
 167
 168         if (m->jobs_in_progress_watch.type != WATCH_INVALID)
 169                 return 0;
 170
 171         m->jobs_in_progress_watch.type = WATCH_JOBS_IN_PROGRESS;
 172         m->jobs_in_progress_watch.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
 173         if (m->jobs_in_progress_watch.fd < 0) {
 174                 log_error("Failed to create timerfd: %m");
 175                 r = -errno;
 176                 goto err;
 177         }
 178
 179         r = manager_jobs_in_progress_mod_timer(m);
 180         if (r < 0) {
 181                 log_error("Failed to set up timer for jobs progress watch: %s", strerror(-r));
 182                 goto err;
 183         }
 184
 185         zero(ev);
 186         ev.events = EPOLLIN;
 187         ev.data.ptr = &m->jobs_in_progress_watch;
 188
 189         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->jobs_in_progress_watch.fd, &ev) < 0) {
 190                 log_error("Failed to add jobs progress timer fd to epoll: %m");
 191                 r = -errno;
 192                 goto err;
 193         }
 194
 195         log_debug("Set up jobs progress timerfd.");
 196
 197         return 0;
 198
 199 err:
 200         if (m->jobs_in_progress_watch.fd >= 0)
 201                 close_nointr_nofail(m->jobs_in_progress_watch.fd);
 202         watch_init(&m->jobs_in_progress_watch);
 203         return r;
 204 }
 205
 206 static void manager_unwatch_jobs_in_progress(Manager *m) {
 207         if (m->jobs_in_progress_watch.type != WATCH_JOBS_IN_PROGRESS)
 208                 return;
 209
 210         assert_se(epoll_ctl(m->epoll_fd, EPOLL_CTL_DEL, m->jobs_in_progress_watch.fd, NULL) >= 0);
 211         close_nointr_nofail(m->jobs_in_progress_watch.fd);
 212         watch_init(&m->jobs_in_progress_watch);
 213         m->jobs_in_progress_iteration = 0;
 214
 215         log_debug("Closed jobs progress timerfd.");
 216 }
 217
 218 #define CYLON_BUFFER_EXTRA (2*strlen(ANSI_RED_ON) + strlen(ANSI_HIGHLIGHT_RED_ON) + 2*strlen(ANSI_HIGHLIGHT_OFF))
 219 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
 220         char *p = buffer;
 221
 222         assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
 223         assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
 224
 225         if (pos > 1) {
 226                 if (pos > 2) {
 227                         memset(p, ' ', pos-2);
 228                         p += pos-2;
 229                 }
 230                 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
 231                 p += strlen(ANSI_RED_ON);
 232                 *p++ = '*';
 233         }
 234
 235         if (pos > 0 && pos <= width) {
 236                 memcpy(p, ANSI_HIGHLIGHT_RED_ON, strlen(ANSI_HIGHLIGHT_RED_ON));
 237                 p += strlen(ANSI_HIGHLIGHT_RED_ON);
 238                 *p++ = '*';
 239         }
 240
 241         memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
 242         p += strlen(ANSI_HIGHLIGHT_OFF);
 243
 244         if (pos < width) {
 245                 memcpy(p, ANSI_RED_ON, strlen(ANSI_RED_ON));
 246                 p += strlen(ANSI_RED_ON);
 247                 *p++ = '*';
 248                 if (pos < width-1) {
 249                         memset(p, ' ', width-1-pos);
 250                         p += width-1-pos;
 251                 }
 252                 memcpy(p, ANSI_HIGHLIGHT_OFF, strlen(ANSI_HIGHLIGHT_OFF));
 253                 p += strlen(ANSI_HIGHLIGHT_OFF);
 254         }
 255         *p = 0;
 256 }
 257
 258 static void manager_print_jobs_in_progress(Manager *m) {
 259         Iterator i;
 260         Job *j;
 261         char *job_of_n = NULL;
 262         unsigned counter = 0, print_nr;
 263         char cylon[6 + CYLON_BUFFER_EXTRA + 1];
 264         unsigned cylon_pos;
 265
 266         print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
 267
 268         HASHMAP_FOREACH(j, m->jobs, i)
 269                 if (j->state == JOB_RUNNING && counter++ == print_nr)
 270                         break;
 271
 272         if (!j)
 273                 return;
 274
 275         cylon_pos = m->jobs_in_progress_iteration % 14;
 276         if (cylon_pos >= 8)
 277                 cylon_pos = 14 - cylon_pos;
 278         draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
 279
 280         if (m->n_running_jobs > 1)
 281                 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
 282                         job_of_n = NULL;
 283
 284         manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
 285                               strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
 286         free(job_of_n);
 287
 288         m->jobs_in_progress_iteration++;
 289 }
 290
 291 static int manager_setup_time_change(Manager *m) {
 292         struct epoll_event ev;
 293         struct itimerspec its;
 294
 295         assert(m);
 296         assert(m->time_change_watch.type == WATCH_INVALID);
 297
 298         /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
 299          * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
 300
 301         m->time_change_watch.type = WATCH_TIME_CHANGE;
 302         m->time_change_watch.fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
 303         if (m->time_change_watch.fd < 0) {
 304                 log_error("Failed to create timerfd: %m");
 305                 return -errno;
 306         }
 307
 308         zero(its);
 309
 310         /* We only care for the cancellation event, hence we set the
 311          * timeout to the latest possible value. */
 312         assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
 313         its.it_value.tv_sec = TIME_T_MAX;
 314
 315         if (timerfd_settime(m->time_change_watch.fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
 316                 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
 317                 close_nointr_nofail(m->time_change_watch.fd);
 318                 watch_init(&m->time_change_watch);
 319                 return 0;
 320         }
 321
 322         zero(ev);
 323         ev.events = EPOLLIN;
 324         ev.data.ptr = &m->time_change_watch;
 325
 326         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->time_change_watch.fd, &ev) < 0) {
 327                 log_error("Failed to add timer change fd to epoll: %m");
 328                 return -errno;
 329         }
 330
 331         log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
 332
 333         return 0;
 334 }
 335
 336 static int enable_special_signals(Manager *m) {
 337         int fd;
 338
 339         assert(m);
 340
 341         /* Enable that we get SIGINT on control-alt-del. In containers
 342          * this will fail with EPERM (older) or EINVAL (newer), so
 343          * ignore that. */
 344         if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
 345                 log_warning("Failed to enable ctrl-alt-del handling: %m");
 346
 347         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 348         if (fd < 0) {
 349                 /* Support systems without virtual console */
 350                 if (fd != -ENOENT)
 351                         log_warning("Failed to open /dev/tty0: %m");
 352         } else {
 353                 /* Enable that we get SIGWINCH on kbrequest */
 354                 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
 355                         log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
 356
 357                 close_nointr_nofail(fd);
 358         }
 359
 360         return 0;
 361 }
 362
 363 static int manager_setup_signals(Manager *m) {
 364         sigset_t mask;
 365         struct epoll_event ev;
 366         struct sigaction sa;
 367
 368         assert(m);
 369
 370         /* We are not interested in SIGSTOP and friends. */
 371         zero(sa);
 372         sa.sa_handler = SIG_DFL;
 373         sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
 374         assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
 375
 376         assert_se(sigemptyset(&mask) == 0);
 377
 378         sigset_add_many(&mask,
 379                         SIGCHLD,     /* Child died */
 380                         SIGTERM,     /* Reexecute daemon */
 381                         SIGHUP,      /* Reload configuration */
 382                         SIGUSR1,     /* systemd/upstart: reconnect to D-Bus */
 383                         SIGUSR2,     /* systemd: dump status */
 384                         SIGINT,      /* Kernel sends us this on control-alt-del */
 385                         SIGWINCH,    /* Kernel sends us this on kbrequest (alt-arrowup) */
 386                         SIGPWR,      /* Some kernel drivers and upsd send us this on power failure */
 387                         SIGRTMIN+0,  /* systemd: start default.target */
 388                         SIGRTMIN+1,  /* systemd: isolate rescue.target */
 389                         SIGRTMIN+2,  /* systemd: isolate emergency.target */
 390                         SIGRTMIN+3,  /* systemd: start halt.target */
 391                         SIGRTMIN+4,  /* systemd: start poweroff.target */
 392                         SIGRTMIN+5,  /* systemd: start reboot.target */
 393                         SIGRTMIN+6,  /* systemd: start kexec.target */
 394                         SIGRTMIN+13, /* systemd: Immediate halt */
 395                         SIGRTMIN+14, /* systemd: Immediate poweroff */
 396                         SIGRTMIN+15, /* systemd: Immediate reboot */
 397                         SIGRTMIN+16, /* systemd: Immediate kexec */
 398                         SIGRTMIN+20, /* systemd: enable status messages */
 399                         SIGRTMIN+21, /* systemd: disable status messages */
 400                         SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
 401                         SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
 402                         SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
 403                         SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
 404                         SIGRTMIN+27, /* systemd: set log target to console */
 405                         SIGRTMIN+28, /* systemd: set log target to kmsg */
 406                         SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
 407                         -1);
 408         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
 409
 410         m->signal_watch.type = WATCH_SIGNAL;
 411         m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 412         if (m->signal_watch.fd < 0)
 413                 return -errno;
 414
 415         zero(ev);
 416         ev.events = EPOLLIN;
 417         ev.data.ptr = &m->signal_watch;
 418
 419         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
 420                 return -errno;
 421
 422         if (m->running_as == SYSTEMD_SYSTEM)
 423                 return enable_special_signals(m);
 424
 425         return 0;
 426 }
 427
 428 static void manager_strip_environment(Manager *m) {
 429         assert(m);
 430
 431         /* Remove variables from the inherited set that are part of
 432          * the container interface:
 433          * http://www.freedesktop.org/wiki/Software/systemd/ContainerInterface */
 434         strv_remove_prefix(m->environment, "container=");
 435         strv_remove_prefix(m->environment, "container_");
 436
 437         /* Remove variables from the inherited set that are part of
 438          * the initrd interface:
 439          * http://www.freedesktop.org/wiki/Software/systemd/InitrdInterface */
 440         strv_remove_prefix(m->environment, "RD_");
 441
 442         /* Drop invalid entries */
 443         strv_env_clean(m->environment);
 444 }
 445
 446 int manager_new(SystemdRunningAs running_as, Manager **_m) {
 447         Manager *m;
 448         int r = -ENOMEM;
 449
 450         assert(_m);
 451         assert(running_as >= 0);
 452         assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
 453
 454         m = new0(Manager, 1);
 455         if (!m)
 456                 return -ENOMEM;
 457
 458         dual_timestamp_get(&m->userspace_timestamp);
 459         dual_timestamp_from_monotonic(&m->kernel_timestamp, 0);
 460 #ifdef ENABLE_EFI
 461         efi_get_boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
 462 #endif
 463
 464         m->running_as = running_as;
 465         m->name_data_slot = m->conn_data_slot = m->subscribed_data_slot = -1;
 466         m->exit_code = _MANAGER_EXIT_CODE_INVALID;
 467         m->pin_cgroupfs_fd = -1;
 468         m->idle_pipe[0] = m->idle_pipe[1] = -1;
 469
 470         watch_init(&m->signal_watch);
 471         watch_init(&m->mount_watch);
 472         watch_init(&m->swap_watch);
 473         watch_init(&m->udev_watch);
 474         watch_init(&m->time_change_watch);
 475         watch_init(&m->jobs_in_progress_watch);
 476
 477         m->epoll_fd = m->dev_autofs_fd = -1;
 478         m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
 479
 480         m->environment = strv_copy(environ);
 481         if (!m->environment)
 482                 goto fail;
 483
 484         manager_strip_environment(m);
 485
 486         if (running_as == SYSTEMD_SYSTEM) {
 487                 m->default_controllers = strv_new("cpu", NULL);
 488                 if (!m->default_controllers)
 489                         goto fail;
 490         }
 491
 492         if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
 493                 goto fail;
 494
 495         if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
 496                 goto fail;
 497
 498         if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
 499                 goto fail;
 500
 501         if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
 502                 goto fail;
 503
 504         if (!(m->watch_bus = hashmap_new(string_hash_func, string_compare_func)))
 505                 goto fail;
 506
 507         m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 508         if (m->epoll_fd < 0)
 509                 goto fail;
 510
 511         r = manager_setup_signals(m);
 512         if (r < 0)
 513                 goto fail;
 514
 515         r = manager_setup_cgroup(m);
 516         if (r < 0)
 517                 goto fail;
 518
 519         r = manager_setup_notify(m);
 520         if (r < 0)
 521                 goto fail;
 522
 523         r = manager_setup_time_change(m);
 524         if (r < 0)
 525                 goto fail;
 526
 527         /* Try to connect to the busses, if possible. */
 528         r = bus_init(m, running_as != SYSTEMD_SYSTEM);
 529         if (r < 0)
 530                 goto fail;
 531
 532         m->taint_usr = dir_is_empty("/usr") > 0;
 533
 534         *_m = m;
 535         return 0;
 536
 537 fail:
 538         manager_free(m);
 539         return r;
 540 }
 541
 542 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
 543         Unit *u;
 544         unsigned n = 0;
 545
 546         assert(m);
 547
 548         while ((u = m->cleanup_queue)) {
 549                 assert(u->in_cleanup_queue);
 550
 551                 unit_free(u);
 552                 n++;
 553         }
 554
 555         return n;
 556 }
 557
 558 enum {
 559         GC_OFFSET_IN_PATH,  /* This one is on the path we were traveling */
 560         GC_OFFSET_UNSURE,   /* No clue */
 561         GC_OFFSET_GOOD,     /* We still need this unit */
 562         GC_OFFSET_BAD,      /* We don't need this unit anymore */
 563         _GC_OFFSET_MAX
 564 };
 565
 566 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
 567         Iterator i;
 568         Unit *other;
 569         bool is_bad;
 570
 571         assert(u);
 572
 573         if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
 574             u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 575             u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
 576                 return;
 577
 578         if (u->in_cleanup_queue)
 579                 goto bad;
 580
 581         if (unit_check_gc(u))
 582                 goto good;
 583
 584         u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
 585
 586         is_bad = true;
 587
 588         SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
 589                 unit_gc_sweep(other, gc_marker);
 590
 591                 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
 592                         goto good;
 593
 594                 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
 595                         is_bad = false;
 596         }
 597
 598         if (is_bad)
 599                 goto bad;
 600
 601         /* We were unable to find anything out about this entry, so
 602          * let's investigate it later */
 603         u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
 604         unit_add_to_gc_queue(u);
 605         return;
 606
 607 bad:
 608         /* We definitely know that this one is not useful anymore, so
 609          * let's mark it for deletion */
 610         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 611         unit_add_to_cleanup_queue(u);
 612         return;
 613
 614 good:
 615         u->gc_marker = gc_marker + GC_OFFSET_GOOD;
 616 }
 617
 618 static unsigned manager_dispatch_gc_queue(Manager *m) {
 619         Unit *u;
 620         unsigned n = 0;
 621         unsigned gc_marker;
 622
 623         assert(m);
 624
 625         if ((m->n_in_gc_queue < GC_QUEUE_ENTRIES_MAX) &&
 626             (m->gc_queue_timestamp <= 0 ||
 627              (m->gc_queue_timestamp + GC_QUEUE_USEC_MAX) > now(CLOCK_MONOTONIC)))
 628                 return 0;
 629
 630         log_debug("Running GC...");
 631
 632         m->gc_marker += _GC_OFFSET_MAX;
 633         if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
 634                 m->gc_marker = 1;
 635
 636         gc_marker = m->gc_marker;
 637
 638         while ((u = m->gc_queue)) {
 639                 assert(u->in_gc_queue);
 640
 641                 unit_gc_sweep(u, gc_marker);
 642
 643                 LIST_REMOVE(Unit, gc_queue, m->gc_queue, u);
 644                 u->in_gc_queue = false;
 645
 646                 n++;
 647
 648                 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 649                     u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
 650                         log_debug_unit(u->id, "Collecting %s", u->id);
 651                         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 652                         unit_add_to_cleanup_queue(u);
 653                 }
 654         }
 655
 656         m->n_in_gc_queue = 0;
 657         m->gc_queue_timestamp = 0;
 658
 659         return n;
 660 }
 661
 662 static void manager_clear_jobs_and_units(Manager *m) {
 663         Unit *u;
 664
 665         assert(m);
 666
 667         while ((u = hashmap_first(m->units)))
 668                 unit_free(u);
 669
 670         manager_dispatch_cleanup_queue(m);
 671
 672         assert(!m->load_queue);
 673         assert(!m->run_queue);
 674         assert(!m->dbus_unit_queue);
 675         assert(!m->dbus_job_queue);
 676         assert(!m->cleanup_queue);
 677         assert(!m->gc_queue);
 678
 679         assert(hashmap_isempty(m->jobs));
 680         assert(hashmap_isempty(m->units));
 681
 682         m->n_on_console = 0;
 683         m->n_running_jobs = 0;
 684 }
 685
 686 void manager_free(Manager *m) {
 687         UnitType c;
 688         int i;
 689
 690         assert(m);
 691
 692         manager_clear_jobs_and_units(m);
 693
 694         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 695                 if (unit_vtable[c]->shutdown)
 696                         unit_vtable[c]->shutdown(m);
 697
 698         /* If we reexecute ourselves, we keep the root cgroup
 699          * around */
 700         manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
 701
 702         manager_undo_generators(m);
 703
 704         bus_done(m);
 705
 706         hashmap_free(m->units);
 707         hashmap_free(m->jobs);
 708         hashmap_free(m->watch_pids);
 709         hashmap_free(m->watch_bus);
 710
 711         if (m->epoll_fd >= 0)
 712                 close_nointr_nofail(m->epoll_fd);
 713         if (m->signal_watch.fd >= 0)
 714                 close_nointr_nofail(m->signal_watch.fd);
 715         if (m->notify_watch.fd >= 0)
 716                 close_nointr_nofail(m->notify_watch.fd);
 717         if (m->time_change_watch.fd >= 0)
 718                 close_nointr_nofail(m->time_change_watch.fd);
 719         if (m->jobs_in_progress_watch.fd >= 0)
 720                 close_nointr_nofail(m->jobs_in_progress_watch.fd);
 721
 722         free(m->notify_socket);
 723
 724         lookup_paths_free(&m->lookup_paths);
 725         strv_free(m->environment);
 726
 727         strv_free(m->default_controllers);
 728
 729         hashmap_free(m->cgroup_bondings);
 730         set_free_free(m->unit_path_cache);
 731
 732         close_pipe(m->idle_pipe);
 733
 734         free(m->switch_root);
 735         free(m->switch_root_init);
 736
 737         for (i = 0; i < RLIMIT_NLIMITS; i++)
 738                 free(m->rlimit[i]);
 739
 740         free(m);
 741 }
 742
 743 int manager_enumerate(Manager *m) {
 744         int r = 0, q;
 745         UnitType c;
 746
 747         assert(m);
 748
 749         /* Let's ask every type to load all units from disk/kernel
 750          * that it might know */
 751         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 752                 if (unit_vtable[c]->enumerate)
 753                         if ((q = unit_vtable[c]->enumerate(m)) < 0)
 754                                 r = q;
 755
 756         manager_dispatch_load_queue(m);
 757         return r;
 758 }
 759
 760 int manager_coldplug(Manager *m) {
 761         int r = 0, q;
 762         Iterator i;
 763         Unit *u;
 764         char *k;
 765
 766         assert(m);
 767
 768         /* Then, let's set up their initial state. */
 769         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 770
 771                 /* ignore aliases */
 772                 if (u->id != k)
 773                         continue;
 774
 775                 if ((q = unit_coldplug(u)) < 0)
 776                         r = q;
 777         }
 778
 779         return r;
 780 }
 781
 782 static void manager_build_unit_path_cache(Manager *m) {
 783         char **i;
 784         DIR _cleanup_free_ *d = NULL;
 785         int r;
 786
 787         assert(m);
 788
 789         set_free_free(m->unit_path_cache);
 790
 791         m->unit_path_cache = set_new(string_hash_func, string_compare_func);
 792         if (!m->unit_path_cache) {
 793                 log_error("Failed to allocate unit path cache.");
 794                 return;
 795         }
 796
 797         /* This simply builds a list of files we know exist, so that
 798          * we don't always have to go to disk */
 799
 800         STRV_FOREACH(i, m->lookup_paths.unit_path) {
 801                 struct dirent *de;
 802
 803                 d = opendir(*i);
 804                 if (!d) {
 805                         if (errno != ENOENT)
 806                                 log_error("Failed to open directory %s: %m", *i);
 807                         continue;
 808                 }
 809
 810                 while ((de = readdir(d))) {
 811                         char *p;
 812
 813                         if (ignore_file(de->d_name))
 814                                 continue;
 815
 816                         p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
 817                         if (!p) {
 818                                 r = -ENOMEM;
 819                                 goto fail;
 820                         }
 821
 822                         r = set_put(m->unit_path_cache, p);
 823                         if (r < 0) {
 824                                 free(p);
 825                                 goto fail;
 826                         }
 827                 }
 828
 829                 closedir(d);
 830                 d = NULL;
 831         }
 832
 833         return;
 834
 835 fail:
 836         log_error("Failed to build unit path cache: %s", strerror(-r));
 837
 838         set_free_free(m->unit_path_cache);
 839         m->unit_path_cache = NULL;
 840 }
 841
 842 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
 843         int r, q;
 844
 845         assert(m);
 846
 847         manager_run_generators(m);
 848
 849         r = lookup_paths_init(
 850                         &m->lookup_paths, m->running_as, true,
 851                         m->generator_unit_path,
 852                         m->generator_unit_path_early,
 853                         m->generator_unit_path_late);
 854         if (r < 0)
 855                 return r;
 856
 857         manager_build_unit_path_cache(m);
 858
 859         /* If we will deserialize make sure that during enumeration
 860          * this is already known, so we increase the counter here
 861          * already */
 862         if (serialization)
 863                 m->n_reloading ++;
 864
 865         /* First, enumerate what we can from all config files */
 866         r = manager_enumerate(m);
 867
 868         /* Second, deserialize if there is something to deserialize */
 869         if (serialization) {
 870                 q = manager_deserialize(m, serialization, fds);
 871                 if (q < 0)
 872                         r = q;
 873         }
 874
 875         /* Any fds left? Find some unit which wants them. This is
 876          * useful to allow container managers to pass some file
 877          * descriptors to us pre-initialized. This enables
 878          * socket-based activation of entire containers. */
 879         if (fdset_size(fds) > 0) {
 880                 q = manager_distribute_fds(m, fds);
 881                 if (q < 0)
 882                         r = q;
 883         }
 884
 885         /* Third, fire things up! */
 886         q = manager_coldplug(m);
 887         if (q < 0)
 888                 r = q;
 889
 890         if (serialization) {
 891                 assert(m->n_reloading > 0);
 892                 m->n_reloading --;
 893         }
 894
 895         return r;
 896 }
 897
 898 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, DBusError *e, Job **_ret) {
 899         int r;
 900         Transaction *tr;
 901
 902         assert(m);
 903         assert(type < _JOB_TYPE_MAX);
 904         assert(unit);
 905         assert(mode < _JOB_MODE_MAX);
 906
 907         if (mode == JOB_ISOLATE && type != JOB_START) {
 908                 dbus_set_error(e, BUS_ERROR_INVALID_JOB_MODE, "Isolate is only valid for start.");
 909                 return -EINVAL;
 910         }
 911
 912         if (mode == JOB_ISOLATE && !unit->allow_isolate) {
 913                 dbus_set_error(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
 914                 return -EPERM;
 915         }
 916
 917         log_debug_unit(unit->id,
 918                        "Trying to enqueue job %s/%s/%s", unit->id,
 919                        job_type_to_string(type), job_mode_to_string(mode));
 920
 921         job_type_collapse(&type, unit);
 922
 923         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
 924         if (!tr)
 925                 return -ENOMEM;
 926
 927         r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
 928                                                  mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
 929                                                  mode == JOB_IGNORE_DEPENDENCIES, e);
 930         if (r < 0)
 931                 goto tr_abort;
 932
 933         if (mode == JOB_ISOLATE) {
 934                 r = transaction_add_isolate_jobs(tr, m);
 935                 if (r < 0)
 936                         goto tr_abort;
 937         }
 938
 939         r = transaction_activate(tr, m, mode, e);
 940         if (r < 0)
 941                 goto tr_abort;
 942
 943         log_debug_unit(unit->id,
 944                        "Enqueued job %s/%s as %u", unit->id,
 945                        job_type_to_string(type), (unsigned) tr->anchor_job->id);
 946
 947         if (_ret)
 948                 *_ret = tr->anchor_job;
 949
 950         transaction_free(tr);
 951         return 0;
 952
 953 tr_abort:
 954         transaction_abort(tr);
 955         transaction_free(tr);
 956         return r;
 957 }
 958
 959 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, DBusError *e, Job **_ret) {
 960         Unit *unit;
 961         int r;
 962
 963         assert(m);
 964         assert(type < _JOB_TYPE_MAX);
 965         assert(name);
 966         assert(mode < _JOB_MODE_MAX);
 967
 968         r = manager_load_unit(m, name, NULL, NULL, &unit);
 969         if (r < 0)
 970                 return r;
 971
 972         return manager_add_job(m, type, unit, mode, override, e, _ret);
 973 }
 974
 975 Job *manager_get_job(Manager *m, uint32_t id) {
 976         assert(m);
 977
 978         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
 979 }
 980
 981 Unit *manager_get_unit(Manager *m, const char *name) {
 982         assert(m);
 983         assert(name);
 984
 985         return hashmap_get(m->units, name);
 986 }
 987
 988 unsigned manager_dispatch_load_queue(Manager *m) {
 989         Unit *u;
 990         unsigned n = 0;
 991
 992         assert(m);
 993
 994         /* Make sure we are not run recursively */
 995         if (m->dispatching_load_queue)
 996                 return 0;
 997
 998         m->dispatching_load_queue = true;
 999
1000         /* Dispatches the load queue. Takes a unit from the queue and
1001          * tries to load its data until the queue is empty */
1002
1003         while ((u = m->load_queue)) {
1004                 assert(u->in_load_queue);
1005
1006                 unit_load(u);
1007                 n++;
1008         }
1009
1010         m->dispatching_load_queue = false;
1011         return n;
1012 }
1013
1014 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1015         Unit *ret;
1016         UnitType t;
1017         int r;
1018
1019         assert(m);
1020         assert(name || path);
1021
1022         /* This will prepare the unit for loading, but not actually
1023          * load anything from disk. */
1024
1025         if (path && !is_path(path)) {
1026                 dbus_set_error(e, BUS_ERROR_INVALID_PATH, "Path %s is not absolute.", path);
1027                 return -EINVAL;
1028         }
1029
1030         if (!name)
1031                 name = path_get_file_name(path);
1032
1033         t = unit_name_to_type(name);
1034
1035         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, false)) {
1036                 dbus_set_error(e, BUS_ERROR_INVALID_NAME, "Unit name %s is not valid.", name);
1037                 return -EINVAL;
1038         }
1039
1040         ret = manager_get_unit(m, name);
1041         if (ret) {
1042                 *_ret = ret;
1043                 return 1;
1044         }
1045
1046         ret = unit_new(m, unit_vtable[t]->object_size);
1047         if (!ret)
1048                 return -ENOMEM;
1049
1050         if (path) {
1051                 ret->fragment_path = strdup(path);
1052                 if (!ret->fragment_path) {
1053                         unit_free(ret);
1054                         return -ENOMEM;
1055                 }
1056         }
1057
1058         if ((r = unit_add_name(ret, name)) < 0) {
1059                 unit_free(ret);
1060                 return r;
1061         }
1062
1063         unit_add_to_load_queue(ret);
1064         unit_add_to_dbus_queue(ret);
1065         unit_add_to_gc_queue(ret);
1066
1067         if (_ret)
1068                 *_ret = ret;
1069
1070         return 0;
1071 }
1072
1073 int manager_load_unit(Manager *m, const char *name, const char *path, DBusError *e, Unit **_ret) {
1074         int r;
1075
1076         assert(m);
1077
1078         /* This will load the service information files, but not actually
1079          * start any services or anything. */
1080
1081         r = manager_load_unit_prepare(m, name, path, e, _ret);
1082         if (r != 0)
1083                 return r;
1084
1085         manager_dispatch_load_queue(m);
1086
1087         if (_ret)
1088                 *_ret = unit_follow_merge(*_ret);
1089
1090         return 0;
1091 }
1092
1093 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1094         Iterator i;
1095         Job *j;
1096
1097         assert(s);
1098         assert(f);
1099
1100         HASHMAP_FOREACH(j, s->jobs, i)
1101                 job_dump(j, f, prefix);
1102 }
1103
1104 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1105         Iterator i;
1106         Unit *u;
1107         const char *t;
1108
1109         assert(s);
1110         assert(f);
1111
1112         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1113                 if (u->id == t)
1114                         unit_dump(u, f, prefix);
1115 }
1116
1117 void manager_clear_jobs(Manager *m) {
1118         Job *j;
1119
1120         assert(m);
1121
1122         while ((j = hashmap_first(m->jobs)))
1123                 /* No need to recurse. We're cancelling all jobs. */
1124                 job_finish_and_invalidate(j, JOB_CANCELED, false);
1125 }
1126
1127 unsigned manager_dispatch_run_queue(Manager *m) {
1128         Job *j;
1129         unsigned n = 0;
1130
1131         if (m->dispatching_run_queue)
1132                 return 0;
1133
1134         m->dispatching_run_queue = true;
1135
1136         while ((j = m->run_queue)) {
1137                 assert(j->installed);
1138                 assert(j->in_run_queue);
1139
1140                 job_run_and_invalidate(j);
1141                 n++;
1142         }
1143
1144         m->dispatching_run_queue = false;
1145
1146         if (hashmap_size(m->jobs) > 0)
1147                 manager_watch_jobs_in_progress(m);
1148
1149         return n;
1150 }
1151
1152 unsigned manager_dispatch_dbus_queue(Manager *m) {
1153         Job *j;
1154         Unit *u;
1155         unsigned n = 0;
1156
1157         assert(m);
1158
1159         if (m->dispatching_dbus_queue)
1160                 return 0;
1161
1162         m->dispatching_dbus_queue = true;
1163
1164         while ((u = m->dbus_unit_queue)) {
1165                 assert(u->in_dbus_queue);
1166
1167                 bus_unit_send_change_signal(u);
1168                 n++;
1169         }
1170
1171         while ((j = m->dbus_job_queue)) {
1172                 assert(j->in_dbus_queue);
1173
1174                 bus_job_send_change_signal(j);
1175                 n++;
1176         }
1177
1178         m->dispatching_dbus_queue = false;
1179         return n;
1180 }
1181
1182 static int manager_process_notify_fd(Manager *m) {
1183         ssize_t n;
1184
1185         assert(m);
1186
1187         for (;;) {
1188                 char buf[4096];
1189                 struct msghdr msghdr;
1190                 struct iovec iovec;
1191                 struct ucred *ucred;
1192                 union {
1193                         struct cmsghdr cmsghdr;
1194                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1195                 } control;
1196                 Unit *u;
1197                 char **tags;
1198
1199                 zero(iovec);
1200                 iovec.iov_base = buf;
1201                 iovec.iov_len = sizeof(buf)-1;
1202
1203                 zero(control);
1204                 zero(msghdr);
1205                 msghdr.msg_iov = &iovec;
1206                 msghdr.msg_iovlen = 1;
1207                 msghdr.msg_control = &control;
1208                 msghdr.msg_controllen = sizeof(control);
1209
1210                 n = recvmsg(m->notify_watch.fd, &msghdr, MSG_DONTWAIT);
1211                 if (n <= 0) {
1212                         if (n >= 0)
1213                                 return -EIO;
1214
1215                         if (errno == EAGAIN || errno == EINTR)
1216                                 break;
1217
1218                         return -errno;
1219                 }
1220
1221                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1222                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
1223                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1224                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1225                         log_warning("Received notify message without credentials. Ignoring.");
1226                         continue;
1227                 }
1228
1229                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1230
1231                 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1232                 if (!u) {
1233                         u = cgroup_unit_by_pid(m, ucred->pid);
1234                         if (!u) {
1235                                 log_warning("Cannot find unit for notify message of PID %lu.", (unsigned long) ucred->pid);
1236                                 continue;
1237                         }
1238                 }
1239
1240                 assert((size_t) n < sizeof(buf));
1241                 buf[n] = 0;
1242                 tags = strv_split(buf, "\n\r");
1243                 if (!tags)
1244                         return log_oom();
1245
1246                 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1247
1248                 if (UNIT_VTABLE(u)->notify_message)
1249                         UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1250
1251                 strv_free(tags);
1252         }
1253
1254         return 0;
1255 }
1256
1257 static int manager_dispatch_sigchld(Manager *m) {
1258         assert(m);
1259
1260         for (;;) {
1261                 siginfo_t si;
1262                 Unit *u;
1263                 int r;
1264
1265                 zero(si);
1266
1267                 /* First we call waitd() for a PID and do not reap the
1268                  * zombie. That way we can still access /proc/$PID for
1269                  * it while it is a zombie. */
1270                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1271
1272                         if (errno == ECHILD)
1273                                 break;
1274
1275                         if (errno == EINTR)
1276                                 continue;
1277
1278                         return -errno;
1279                 }
1280
1281                 if (si.si_pid <= 0)
1282                         break;
1283
1284                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1285                         char _cleanup_free_ *name = NULL;
1286
1287                         get_process_comm(si.si_pid, &name);
1288                         log_debug("Got SIGCHLD for process %lu (%s)", (unsigned long) si.si_pid, strna(name));
1289                 }
1290
1291                 /* Let's flush any message the dying child might still
1292                  * have queued for us. This ensures that the process
1293                  * still exists in /proc so that we can figure out
1294                  * which cgroup and hence unit it belongs to. */
1295                 r = manager_process_notify_fd(m);
1296                 if (r < 0)
1297                         return r;
1298
1299                 /* And now figure out the unit this belongs to */
1300                 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1301                 if (!u)
1302                         u = cgroup_unit_by_pid(m, si.si_pid);
1303
1304                 /* And now, we actually reap the zombie. */
1305                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1306                         if (errno == EINTR)
1307                                 continue;
1308
1309                         return -errno;
1310                 }
1311
1312                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1313                         continue;
1314
1315                 log_debug("Child %lu died (code=%s, status=%i/%s)",
1316                           (long unsigned) si.si_pid,
1317                           sigchld_code_to_string(si.si_code),
1318                           si.si_status,
1319                           strna(si.si_code == CLD_EXITED
1320                                 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1321                                 : signal_to_string(si.si_status)));
1322
1323                 if (!u)
1324                         continue;
1325
1326                 log_debug_unit(u->id,
1327                                "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1328
1329                 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1330                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1331         }
1332
1333         return 0;
1334 }
1335
1336 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1337         int r;
1338         DBusError error;
1339
1340         dbus_error_init(&error);
1341
1342         log_debug_unit(name, "Activating special unit %s", name);
1343
1344         r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1345         if (r < 0)
1346                 log_error_unit(name,
1347                                "Failed to enqueue %s job: %s", name, bus_error(&error, r));
1348
1349         dbus_error_free(&error);
1350
1351         return r;
1352 }
1353
1354 static int manager_process_signal_fd(Manager *m) {
1355         ssize_t n;
1356         struct signalfd_siginfo sfsi;
1357         bool sigchld = false;
1358
1359         assert(m);
1360
1361         for (;;) {
1362                 n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi));
1363                 if (n != sizeof(sfsi)) {
1364
1365                         if (n >= 0)
1366                                 return -EIO;
1367
1368                         if (errno == EINTR || errno == EAGAIN)
1369                                 break;
1370
1371                         return -errno;
1372                 }
1373
1374                 if (sfsi.ssi_pid > 0) {
1375                         char *p = NULL;
1376
1377                         get_process_comm(sfsi.ssi_pid, &p);
1378
1379                         log_debug("Received SIG%s from PID %lu (%s).",
1380                                   signal_to_string(sfsi.ssi_signo),
1381                                   (unsigned long) sfsi.ssi_pid, strna(p));
1382                         free(p);
1383                 } else
1384                         log_debug("Received SIG%s.", signal_to_string(sfsi.ssi_signo));
1385
1386                 switch (sfsi.ssi_signo) {
1387
1388                 case SIGCHLD:
1389                         sigchld = true;
1390                         break;
1391
1392                 case SIGTERM:
1393                         if (m->running_as == SYSTEMD_SYSTEM) {
1394                                 /* This is for compatibility with the
1395                                  * original sysvinit */
1396                                 m->exit_code = MANAGER_REEXECUTE;
1397                                 break;
1398                         }
1399
1400                         /* Fall through */
1401
1402                 case SIGINT:
1403                         if (m->running_as == SYSTEMD_SYSTEM) {
1404                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE);
1405                                 break;
1406                         }
1407
1408                         /* Run the exit target if there is one, if not, just exit. */
1409                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1410                                 m->exit_code = MANAGER_EXIT;
1411                                 return 0;
1412                         }
1413
1414                         break;
1415
1416                 case SIGWINCH:
1417                         if (m->running_as == SYSTEMD_SYSTEM)
1418                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1419
1420                         /* This is a nop on non-init */
1421                         break;
1422
1423                 case SIGPWR:
1424                         if (m->running_as == SYSTEMD_SYSTEM)
1425                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1426
1427                         /* This is a nop on non-init */
1428                         break;
1429
1430                 case SIGUSR1: {
1431                         Unit *u;
1432
1433                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1434
1435                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1436                                 log_info("Trying to reconnect to bus...");
1437                                 bus_init(m, true);
1438                         }
1439
1440                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1441                                 log_info("Loading D-Bus service...");
1442                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1443                         }
1444
1445                         break;
1446                 }
1447
1448                 case SIGUSR2: {
1449                         FILE *f;
1450                         char *dump = NULL;
1451                         size_t size;
1452
1453                         if (!(f = open_memstream(&dump, &size))) {
1454                                 log_warning("Failed to allocate memory stream.");
1455                                 break;
1456                         }
1457
1458                         manager_dump_units(m, f, "\t");
1459                         manager_dump_jobs(m, f, "\t");
1460
1461                         if (ferror(f)) {
1462                                 fclose(f);
1463                                 free(dump);
1464                                 log_warning("Failed to write status stream");
1465                                 break;
1466                         }
1467
1468                         fclose(f);
1469                         log_dump(LOG_INFO, dump);
1470                         free(dump);
1471
1472                         break;
1473                 }
1474
1475                 case SIGHUP:
1476                         m->exit_code = MANAGER_RELOAD;
1477                         break;
1478
1479                 default: {
1480
1481                         /* Starting SIGRTMIN+0 */
1482                         static const char * const target_table[] = {
1483                                 [0] = SPECIAL_DEFAULT_TARGET,
1484                                 [1] = SPECIAL_RESCUE_TARGET,
1485                                 [2] = SPECIAL_EMERGENCY_TARGET,
1486                                 [3] = SPECIAL_HALT_TARGET,
1487                                 [4] = SPECIAL_POWEROFF_TARGET,
1488                                 [5] = SPECIAL_REBOOT_TARGET,
1489                                 [6] = SPECIAL_KEXEC_TARGET
1490                         };
1491
1492                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1493                         static const ManagerExitCode code_table[] = {
1494                                 [0] = MANAGER_HALT,
1495                                 [1] = MANAGER_POWEROFF,
1496                                 [2] = MANAGER_REBOOT,
1497                                 [3] = MANAGER_KEXEC
1498                         };
1499
1500                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1501                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1502                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1503                                 manager_start_target(m, target_table[idx],
1504                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1505                                 break;
1506                         }
1507
1508                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1509                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1510                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1511                                 break;
1512                         }
1513
1514                         switch (sfsi.ssi_signo - SIGRTMIN) {
1515
1516                         case 20:
1517                                 log_debug("Enabling showing of status.");
1518                                 manager_set_show_status(m, true);
1519                                 break;
1520
1521                         case 21:
1522                                 log_debug("Disabling showing of status.");
1523                                 manager_set_show_status(m, false);
1524                                 break;
1525
1526                         case 22:
1527                                 log_set_max_level(LOG_DEBUG);
1528                                 log_notice("Setting log level to debug.");
1529                                 break;
1530
1531                         case 23:
1532                                 log_set_max_level(LOG_INFO);
1533                                 log_notice("Setting log level to info.");
1534                                 break;
1535
1536                         case 24:
1537                                 if (m->running_as == SYSTEMD_USER) {
1538                                         m->exit_code = MANAGER_EXIT;
1539                                         return 0;
1540                                 }
1541
1542                                 /* This is a nop on init */
1543                                 break;
1544
1545                         case 26:
1546                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1547                                 log_notice("Setting log target to journal-or-kmsg.");
1548                                 break;
1549
1550                         case 27:
1551                                 log_set_target(LOG_TARGET_CONSOLE);
1552                                 log_notice("Setting log target to console.");
1553                                 break;
1554
1555                         case 28:
1556                                 log_set_target(LOG_TARGET_KMSG);
1557                                 log_notice("Setting log target to kmsg.");
1558                                 break;
1559
1560                         case 29:
1561                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1562                                 log_notice("Setting log target to syslog-or-kmsg.");
1563                                 break;
1564
1565                         default:
1566                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1567                         }
1568                 }
1569                 }
1570         }
1571
1572         if (sigchld)
1573                 return manager_dispatch_sigchld(m);
1574
1575         return 0;
1576 }
1577
1578 static int process_event(Manager *m, struct epoll_event *ev) {
1579         int r;
1580         Watch *w;
1581
1582         assert(m);
1583         assert(ev);
1584
1585         assert_se(w = ev->data.ptr);
1586
1587         if (w->type == WATCH_INVALID)
1588                 return 0;
1589
1590         switch (w->type) {
1591
1592         case WATCH_SIGNAL:
1593
1594                 /* An incoming signal? */
1595                 if (ev->events != EPOLLIN)
1596                         return -EINVAL;
1597
1598                 if ((r = manager_process_signal_fd(m)) < 0)
1599                         return r;
1600
1601                 break;
1602
1603         case WATCH_NOTIFY:
1604
1605                 /* An incoming daemon notification event? */
1606                 if (ev->events != EPOLLIN)
1607                         return -EINVAL;
1608
1609                 if ((r = manager_process_notify_fd(m)) < 0)
1610                         return r;
1611
1612                 break;
1613
1614         case WATCH_FD:
1615
1616                 /* Some fd event, to be dispatched to the units */
1617                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1618                 break;
1619
1620         case WATCH_UNIT_TIMER:
1621         case WATCH_JOB_TIMER: {
1622                 uint64_t v;
1623                 ssize_t k;
1624
1625                 /* Some timer event, to be dispatched to the units */
1626                 k = read(w->fd, &v, sizeof(v));
1627                 if (k != sizeof(v)) {
1628
1629                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
1630                                 break;
1631
1632                         log_error("Failed to read timer event counter: %s", k < 0 ? strerror(-k) : "Short read");
1633                         return k < 0 ? -errno : -EIO;
1634                 }
1635
1636                 if (w->type == WATCH_UNIT_TIMER)
1637                         UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1638                 else
1639                         job_timer_event(w->data.job, v, w);
1640                 break;
1641         }
1642
1643         case WATCH_MOUNT:
1644                 /* Some mount table change, intended for the mount subsystem */
1645                 mount_fd_event(m, ev->events);
1646                 break;
1647
1648         case WATCH_SWAP:
1649                 /* Some swap table change, intended for the swap subsystem */
1650                 swap_fd_event(m, ev->events);
1651                 break;
1652
1653         case WATCH_UDEV:
1654                 /* Some notification from udev, intended for the device subsystem */
1655                 device_fd_event(m, ev->events);
1656                 break;
1657
1658         case WATCH_DBUS_WATCH:
1659                 bus_watch_event(m, w, ev->events);
1660                 break;
1661
1662         case WATCH_DBUS_TIMEOUT:
1663                 bus_timeout_event(m, w, ev->events);
1664                 break;
1665
1666         case WATCH_TIME_CHANGE: {
1667                 Unit *u;
1668                 Iterator i;
1669
1670                 log_struct(LOG_INFO,
1671                            MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1672                            "MESSAGE=Time has been changed",
1673                            NULL);
1674
1675                 /* Restart the watch */
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 (hashmap_size(m->jobs) > 0) {
2371                 manager_jobs_in_progress_mod_timer(m);
2372                 return;
2373         }
2374
2375         /* Notify Type=idle units that we are done now */
2376         close_pipe(m->idle_pipe);
2377
2378         /* Turn off confirm spawn now */
2379         m->confirm_spawn = false;
2380
2381         manager_unwatch_jobs_in_progress(m);
2382
2383         if (dual_timestamp_is_set(&m->finish_timestamp))
2384                 return;
2385
2386         dual_timestamp_get(&m->finish_timestamp);
2387
2388         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2389
2390                 /* Note that m->kernel_usec.monotonic is always at 0,
2391                  * and m->firmware_usec.monotonic and
2392                  * m->loader_usec.monotonic should be considered
2393                  * negative values. */
2394
2395                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2396                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2397                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2398                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2399
2400                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2401
2402                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2403                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2404
2405                         if (!log_on_console())
2406                                 log_struct(LOG_INFO,
2407                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2408                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2409                                            "INITRD_USEC=%llu", (unsigned long long) initrd_usec,
2410                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2411                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2412                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2413                                            format_timespan(initrd, sizeof(initrd), initrd_usec),
2414                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2415                                            format_timespan(sum, sizeof(sum), total_usec),
2416                                            NULL);
2417                 } else {
2418                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2419                         initrd_usec = 0;
2420
2421                         if (!log_on_console())
2422                                 log_struct(LOG_INFO,
2423                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2424                                            "KERNEL_USEC=%llu", (unsigned long long) kernel_usec,
2425                                            "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2426                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2427                                            format_timespan(kernel, sizeof(kernel), kernel_usec),
2428                                            format_timespan(userspace, sizeof(userspace), userspace_usec),
2429                                            format_timespan(sum, sizeof(sum), total_usec),
2430                                            NULL);
2431                 }
2432         } else {
2433                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2434                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2435
2436                 if (!log_on_console())
2437                         log_struct(LOG_INFO,
2438                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2439                                    "USERSPACE_USEC=%llu", (unsigned long long) userspace_usec,
2440                                    "MESSAGE=Startup finished in %s.",
2441                                    format_timespan(sum, sizeof(sum), total_usec),
2442                                    NULL);
2443         }
2444
2445         bus_broadcast_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2446
2447         sd_notifyf(false,
2448                    "READY=1\nSTATUS=Startup finished in %s.",
2449                    format_timespan(sum, sizeof(sum), total_usec));
2450 }
2451
2452 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2453         char *p;
2454         int r;
2455
2456         assert(m);
2457         assert(generator);
2458         assert(name);
2459
2460         if (*generator)
2461                 return 0;
2462
2463         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2464
2465                 p = strappend("/run/systemd/", name);
2466                 if (!p)
2467                         return log_oom();
2468
2469                 r = mkdir_p_label(p, 0755);
2470                 if (r < 0) {
2471                         log_error("Failed to create generator directory %s: %s",
2472                                   p, strerror(-r));
2473                         free(p);
2474                         return r;
2475                 }
2476         } else {
2477                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2478                 if (!p)
2479                         return log_oom();
2480
2481                 if (!mkdtemp(p)) {
2482                         free(p);
2483                         log_error("Failed to create generator directory %s: %m",
2484                                   p);
2485                         return -errno;
2486                 }
2487         }
2488
2489         *generator = p;
2490         return 0;
2491 }
2492
2493 static void trim_generator_dir(Manager *m, char **generator) {
2494         assert(m);
2495         assert(generator);
2496
2497         if (!*generator)
2498                 return;
2499
2500         if (rmdir(*generator) >= 0) {
2501                 free(*generator);
2502                 *generator = NULL;
2503         }
2504
2505         return;
2506 }
2507
2508 void manager_run_generators(Manager *m) {
2509         DIR *d = NULL;
2510         const char *generator_path;
2511         const char *argv[5];
2512         mode_t u;
2513         int r;
2514
2515         assert(m);
2516
2517         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2518         d = opendir(generator_path);
2519         if (!d) {
2520                 if (errno == ENOENT)
2521                         return;
2522
2523                 log_error("Failed to enumerate generator directory %s: %m",
2524                           generator_path);
2525                 return;
2526         }
2527
2528         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2529         if (r < 0)
2530                 goto finish;
2531
2532         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2533         if (r < 0)
2534                 goto finish;
2535
2536         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2537         if (r < 0)
2538                 goto finish;
2539
2540         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2541         argv[1] = m->generator_unit_path;
2542         argv[2] = m->generator_unit_path_early;
2543         argv[3] = m->generator_unit_path_late;
2544         argv[4] = NULL;
2545
2546         u = umask(0022);
2547         execute_directory(generator_path, d, (char**) argv);
2548         umask(u);
2549
2550         trim_generator_dir(m, &m->generator_unit_path);
2551         trim_generator_dir(m, &m->generator_unit_path_early);
2552         trim_generator_dir(m, &m->generator_unit_path_late);
2553
2554 finish:
2555         if (d)
2556                 closedir(d);
2557 }
2558
2559 static void remove_generator_dir(Manager *m, char **generator) {
2560         assert(m);
2561         assert(generator);
2562
2563         if (!*generator)
2564                 return;
2565
2566         strv_remove(m->lookup_paths.unit_path, *generator);
2567         rm_rf(*generator, false, true, false);
2568
2569         free(*generator);
2570         *generator = NULL;
2571 }
2572
2573 void manager_undo_generators(Manager *m) {
2574         assert(m);
2575
2576         remove_generator_dir(m, &m->generator_unit_path);
2577         remove_generator_dir(m, &m->generator_unit_path_early);
2578         remove_generator_dir(m, &m->generator_unit_path_late);
2579 }
2580
2581 int manager_set_default_controllers(Manager *m, char **controllers) {
2582         char **l;
2583
2584         assert(m);
2585
2586         l = strv_copy(controllers);
2587         if (!l)
2588                 return -ENOMEM;
2589
2590         strv_free(m->default_controllers);
2591         m->default_controllers = l;
2592
2593         cg_shorten_controllers(m->default_controllers);
2594
2595         return 0;
2596 }
2597
2598 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2599         int i;
2600
2601         assert(m);
2602
2603         for (i = 0; i < RLIMIT_NLIMITS; i++) {
2604                 if (!default_rlimit[i])
2605                         continue;
2606
2607                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2608                 if (!m->rlimit[i])
2609                         return -ENOMEM;
2610         }
2611
2612         return 0;
2613 }
2614
2615 void manager_recheck_journal(Manager *m) {
2616         Unit *u;
2617
2618         assert(m);
2619
2620         if (m->running_as != SYSTEMD_SYSTEM)
2621                 return;
2622
2623         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2624         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2625                 log_close_journal();
2626                 return;
2627         }
2628
2629         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2630         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2631                 log_close_journal();
2632                 return;
2633         }
2634
2635         /* Hmm, OK, so the socket is fully up and the service is up
2636          * too, then let's make use of the thing. */
2637         log_open();
2638 }
2639
2640 void manager_set_show_status(Manager *m, bool b) {
2641         assert(m);
2642
2643         if (m->running_as != SYSTEMD_SYSTEM)
2644                 return;
2645
2646         m->show_status = b;
2647
2648         if (b)
2649                 touch("/run/systemd/show-status");
2650         else
2651                 unlink("/run/systemd/show-status");
2652 }
2653
2654 static bool manager_get_show_status(Manager *m) {
2655         assert(m);
2656
2657         if (m->running_as != SYSTEMD_SYSTEM)
2658                 return false;
2659
2660         if (m->show_status)
2661                 return true;
2662
2663         /* If Plymouth is running make sure we show the status, so
2664          * that there's something nice to see when people press Esc */
2665
2666         return plymouth_running();
2667 }
2668
2669 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2670         va_list ap;
2671
2672         if (!manager_get_show_status(m))
2673                 return;
2674
2675         /* XXX We should totally drop the check for ephemeral here
2676          * and thus effectively make 'Type=idle' pointless. */
2677         if (ephemeral && m->n_on_console > 0)
2678                 return;
2679
2680         if (!manager_is_booting_or_shutting_down(m))
2681                 return;
2682
2683         va_start(ap, format);
2684         status_vprintf(status, true, ephemeral, format, ap);
2685         va_end(ap);
2686 }
2687
2688 void watch_init(Watch *w) {
2689         assert(w);
2690
2691         w->type = WATCH_INVALID;
2692         w->fd = -1;
2693 }