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