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