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                 if (n == 0)
1525                         return -ECONNRESET;
1526
1527                 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1528                         if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1529
1530                                 fd_array = (int*) CMSG_DATA(cmsg);
1531                                 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1532
1533                         } else if (cmsg->cmsg_level == SOL_SOCKET &&
1534                                    cmsg->cmsg_type == SCM_CREDENTIALS &&
1535                                    cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1536
1537                                 ucred = (struct ucred*) CMSG_DATA(cmsg);
1538                         }
1539                 }
1540
1541                 if (n_fds > 0) {
1542                         assert(fd_array);
1543
1544                         r = fdset_new_array(&fds, fd_array, n_fds);
1545                         if (r < 0) {
1546                                 close_many(fd_array, n_fds);
1547                                 return log_oom();
1548                         }
1549                 }
1550
1551                 if (!ucred || ucred->pid <= 0) {
1552                         log_warning("Received notify message without valid credentials. Ignoring.");
1553                         continue;
1554                 }
1555
1556                 if ((size_t) n >= sizeof(buf)) {
1557                         log_warning("Received notify message exceeded maximum size. Ignoring.");
1558                         continue;
1559                 }
1560
1561                 buf[n] = 0;
1562
1563                 /* Notify every unit that might be interested, but try
1564                  * to avoid notifying the same one multiple times. */
1565                 u1 = manager_get_unit_by_pid(m, ucred->pid);
1566                 if (u1) {
1567                         manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
1568                         found = true;
1569                 }
1570
1571                 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1572                 if (u2 && u2 != u1) {
1573                         manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
1574                         found = true;
1575                 }
1576
1577                 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1578                 if (u3 && u3 != u2 && u3 != u1) {
1579                         manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
1580                         found = true;
1581                 }
1582
1583                 if (!found)
1584                         log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1585
1586                 if (fdset_size(fds) > 0)
1587                         log_warning("Got auxiliary fds with notification message, closing all.");
1588         }
1589
1590         return 0;
1591 }
1592
1593 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1594         assert(m);
1595         assert(u);
1596         assert(si);
1597
1598         log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1599
1600         unit_unwatch_pid(u, si->si_pid);
1601         UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1602 }
1603
1604 static int manager_dispatch_sigchld(Manager *m) {
1605         assert(m);
1606
1607         for (;;) {
1608                 siginfo_t si = {};
1609
1610                 /* First we call waitd() for a PID and do not reap the
1611                  * zombie. That way we can still access /proc/$PID for
1612                  * it while it is a zombie. */
1613                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1614
1615                         if (errno == ECHILD)
1616                                 break;
1617
1618                         if (errno == EINTR)
1619                                 continue;
1620
1621                         return -errno;
1622                 }
1623
1624                 if (si.si_pid <= 0)
1625                         break;
1626
1627                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1628                         _cleanup_free_ char *name = NULL;
1629                         Unit *u1, *u2, *u3;
1630
1631                         get_process_comm(si.si_pid, &name);
1632
1633                         log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1634                                   si.si_pid, strna(name),
1635                                   sigchld_code_to_string(si.si_code),
1636                                   si.si_status,
1637                                   strna(si.si_code == CLD_EXITED
1638                                         ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1639                                         : signal_to_string(si.si_status)));
1640
1641                         /* And now figure out the unit this belongs
1642                          * to, it might be multiple... */
1643                         u1 = manager_get_unit_by_pid(m, si.si_pid);
1644                         if (u1)
1645                                 invoke_sigchld_event(m, u1, &si);
1646                         u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1647                         if (u2 && u2 != u1)
1648                                 invoke_sigchld_event(m, u2, &si);
1649                         u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1650                         if (u3 && u3 != u2 && u3 != u1)
1651                                 invoke_sigchld_event(m, u3, &si);
1652                 }
1653
1654                 /* And now, we actually reap the zombie. */
1655                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1656                         if (errno == EINTR)
1657                                 continue;
1658
1659                         return -errno;
1660                 }
1661         }
1662
1663         return 0;
1664 }
1665
1666 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1667         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1668         int r;
1669
1670         log_unit_debug(name, "Activating special unit %s", name);
1671
1672         r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1673         if (r < 0)
1674                 log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1675
1676         return r;
1677 }
1678
1679 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1680         Manager *m = userdata;
1681         ssize_t n;
1682         struct signalfd_siginfo sfsi;
1683         bool sigchld = false;
1684
1685         assert(m);
1686         assert(m->signal_fd == fd);
1687
1688         if (revents != EPOLLIN) {
1689                 log_warning("Got unexpected events from signal file descriptor.");
1690                 return 0;
1691         }
1692
1693         for (;;) {
1694                 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1695                 if (n != sizeof(sfsi)) {
1696
1697                         if (n >= 0)
1698                                 return -EIO;
1699
1700                         if (errno == EINTR || errno == EAGAIN)
1701                                 break;
1702
1703                         return -errno;
1704                 }
1705
1706                 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1707                                     (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1708                                     ? LOG_DEBUG : LOG_INFO,
1709                                     &sfsi);
1710
1711                 switch (sfsi.ssi_signo) {
1712
1713                 case SIGCHLD:
1714                         sigchld = true;
1715                         break;
1716
1717                 case SIGTERM:
1718                         if (m->running_as == SYSTEMD_SYSTEM) {
1719                                 /* This is for compatibility with the
1720                                  * original sysvinit */
1721                                 m->exit_code = MANAGER_REEXECUTE;
1722                                 break;
1723                         }
1724
1725                         /* Fall through */
1726
1727                 case SIGINT:
1728                         if (m->running_as == SYSTEMD_SYSTEM) {
1729                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1730                                 break;
1731                         }
1732
1733                         /* Run the exit target if there is one, if not, just exit. */
1734                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1735                                 m->exit_code = MANAGER_EXIT;
1736                                 return 0;
1737                         }
1738
1739                         break;
1740
1741                 case SIGWINCH:
1742                         if (m->running_as == SYSTEMD_SYSTEM)
1743                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1744
1745                         /* This is a nop on non-init */
1746                         break;
1747
1748                 case SIGPWR:
1749                         if (m->running_as == SYSTEMD_SYSTEM)
1750                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1751
1752                         /* This is a nop on non-init */
1753                         break;
1754
1755                 case SIGUSR1: {
1756                         Unit *u;
1757
1758                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1759
1760                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1761                                 log_info("Trying to reconnect to bus...");
1762                                 bus_init(m, true);
1763                         }
1764
1765                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1766                                 log_info("Loading D-Bus service...");
1767                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1768                         }
1769
1770                         break;
1771                 }
1772
1773                 case SIGUSR2: {
1774                         _cleanup_free_ char *dump = NULL;
1775                         _cleanup_fclose_ FILE *f = NULL;
1776                         size_t size;
1777
1778                         f = open_memstream(&dump, &size);
1779                         if (!f) {
1780                                 log_warning("Failed to allocate memory stream.");
1781                                 break;
1782                         }
1783
1784                         manager_dump_units(m, f, "\t");
1785                         manager_dump_jobs(m, f, "\t");
1786
1787                         if (ferror(f)) {
1788                                 log_warning("Failed to write status stream");
1789                                 break;
1790                         }
1791
1792                         if (fflush(f)) {
1793                                 log_warning("Failed to flush status stream");
1794                                 break;
1795                         }
1796
1797                         log_dump(LOG_INFO, dump);
1798                         break;
1799                 }
1800
1801                 case SIGHUP:
1802                         m->exit_code = MANAGER_RELOAD;
1803                         break;
1804
1805                 default: {
1806
1807                         /* Starting SIGRTMIN+0 */
1808                         static const char * const target_table[] = {
1809                                 [0] = SPECIAL_DEFAULT_TARGET,
1810                                 [1] = SPECIAL_RESCUE_TARGET,
1811                                 [2] = SPECIAL_EMERGENCY_TARGET,
1812                                 [3] = SPECIAL_HALT_TARGET,
1813                                 [4] = SPECIAL_POWEROFF_TARGET,
1814                                 [5] = SPECIAL_REBOOT_TARGET,
1815                                 [6] = SPECIAL_KEXEC_TARGET
1816                         };
1817
1818                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1819                         static const ManagerExitCode code_table[] = {
1820                                 [0] = MANAGER_HALT,
1821                                 [1] = MANAGER_POWEROFF,
1822                                 [2] = MANAGER_REBOOT,
1823                                 [3] = MANAGER_KEXEC
1824                         };
1825
1826                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1827                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1828                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1829                                 manager_start_target(m, target_table[idx],
1830                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1831                                 break;
1832                         }
1833
1834                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1835                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1836                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1837                                 break;
1838                         }
1839
1840                         switch (sfsi.ssi_signo - SIGRTMIN) {
1841
1842                         case 20:
1843                                 log_debug("Enabling showing of status.");
1844                                 manager_set_show_status(m, SHOW_STATUS_YES);
1845                                 break;
1846
1847                         case 21:
1848                                 log_debug("Disabling showing of status.");
1849                                 manager_set_show_status(m, SHOW_STATUS_NO);
1850                                 break;
1851
1852                         case 22:
1853                                 log_set_max_level(LOG_DEBUG);
1854                                 log_notice("Setting log level to debug.");
1855                                 break;
1856
1857                         case 23:
1858                                 log_set_max_level(LOG_INFO);
1859                                 log_notice("Setting log level to info.");
1860                                 break;
1861
1862                         case 24:
1863                                 if (m->running_as == SYSTEMD_USER) {
1864                                         m->exit_code = MANAGER_EXIT;
1865                                         return 0;
1866                                 }
1867
1868                                 /* This is a nop on init */
1869                                 break;
1870
1871                         case 26:
1872                         case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1873                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1874                                 log_notice("Setting log target to journal-or-kmsg.");
1875                                 break;
1876
1877                         case 27:
1878                                 log_set_target(LOG_TARGET_CONSOLE);
1879                                 log_notice("Setting log target to console.");
1880                                 break;
1881
1882                         case 28:
1883                                 log_set_target(LOG_TARGET_KMSG);
1884                                 log_notice("Setting log target to kmsg.");
1885                                 break;
1886
1887                         default:
1888                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1889                         }
1890                 }
1891                 }
1892         }
1893
1894         if (sigchld)
1895                 manager_dispatch_sigchld(m);
1896
1897         return 0;
1898 }
1899
1900 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1901         Manager *m = userdata;
1902         Iterator i;
1903         Unit *u;
1904
1905         assert(m);
1906         assert(m->time_change_fd == fd);
1907
1908         log_struct(LOG_INFO,
1909                    LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1910                    LOG_MESSAGE("Time has been changed"),
1911                    NULL);
1912
1913         /* Restart the watch */
1914         m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1915         m->time_change_fd = safe_close(m->time_change_fd);
1916
1917         manager_setup_time_change(m);
1918
1919         HASHMAP_FOREACH(u, m->units, i)
1920                 if (UNIT_VTABLE(u)->time_change)
1921                         UNIT_VTABLE(u)->time_change(u);
1922
1923         return 0;
1924 }
1925
1926 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1927         Manager *m = userdata;
1928
1929         assert(m);
1930         assert(m->idle_pipe[2] == fd);
1931
1932         m->no_console_output = m->n_on_console > 0;
1933
1934         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1935         manager_close_idle_pipe(m);
1936
1937         return 0;
1938 }
1939
1940 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1941         Manager *m = userdata;
1942         int r;
1943         uint64_t next;
1944
1945         assert(m);
1946         assert(source);
1947
1948         manager_print_jobs_in_progress(m);
1949
1950         next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1951         r = sd_event_source_set_time(source, next);
1952         if (r < 0)
1953                 return r;
1954
1955         return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1956 }
1957
1958 int manager_loop(Manager *m) {
1959         int r;
1960
1961         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1962
1963         assert(m);
1964         m->exit_code = MANAGER_OK;
1965
1966         /* Release the path cache */
1967         set_free_free(m->unit_path_cache);
1968         m->unit_path_cache = NULL;
1969
1970         manager_check_finished(m);
1971
1972         /* There might still be some zombies hanging around from
1973          * before we were exec()'ed. Let's reap them. */
1974         r = manager_dispatch_sigchld(m);
1975         if (r < 0)
1976                 return r;
1977
1978         while (m->exit_code == MANAGER_OK) {
1979                 usec_t wait_usec;
1980
1981                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1982                         watchdog_ping();
1983
1984                 if (!ratelimit_test(&rl)) {
1985                         /* Yay, something is going seriously wrong, pause a little */
1986                         log_warning("Looping too fast. Throttling execution a little.");
1987                         sleep(1);
1988                         continue;
1989                 }
1990
1991                 if (manager_dispatch_load_queue(m) > 0)
1992                         continue;
1993
1994                 if (manager_dispatch_gc_queue(m) > 0)
1995                         continue;
1996
1997                 if (manager_dispatch_cleanup_queue(m) > 0)
1998                         continue;
1999
2000                 if (manager_dispatch_cgroup_queue(m) > 0)
2001                         continue;
2002
2003                 if (manager_dispatch_dbus_queue(m) > 0)
2004                         continue;
2005
2006                 /* Sleep for half the watchdog time */
2007                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
2008                         wait_usec = m->runtime_watchdog / 2;
2009                         if (wait_usec <= 0)
2010                                 wait_usec = 1;
2011                 } else
2012                         wait_usec = USEC_INFINITY;
2013
2014                 r = sd_event_run(m->event, wait_usec);
2015                 if (r < 0)
2016                         return log_error_errno(r, "Failed to run event loop: %m");
2017         }
2018
2019         return m->exit_code;
2020 }
2021
2022 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2023         _cleanup_free_ char *n = NULL;
2024         Unit *u;
2025         int r;
2026
2027         assert(m);
2028         assert(s);
2029         assert(_u);
2030
2031         r = unit_name_from_dbus_path(s, &n);
2032         if (r < 0)
2033                 return r;
2034
2035         r = manager_load_unit(m, n, NULL, e, &u);
2036         if (r < 0)
2037                 return r;
2038
2039         *_u = u;
2040
2041         return 0;
2042 }
2043
2044 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2045         const char *p;
2046         unsigned id;
2047         Job *j;
2048         int r;
2049
2050         assert(m);
2051         assert(s);
2052         assert(_j);
2053
2054         p = startswith(s, "/org/freedesktop/systemd1/job/");
2055         if (!p)
2056                 return -EINVAL;
2057
2058         r = safe_atou(p, &id);
2059         if (r < 0)
2060                 return r;
2061
2062         j = manager_get_job(m, id);
2063         if (!j)
2064                 return -ENOENT;
2065
2066         *_j = j;
2067
2068         return 0;
2069 }
2070
2071 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2072
2073 #ifdef HAVE_AUDIT
2074         _cleanup_free_ char *p = NULL;
2075         const char *msg;
2076         int audit_fd;
2077
2078         audit_fd = get_audit_fd();
2079         if (audit_fd < 0)
2080                 return;
2081
2082         /* Don't generate audit events if the service was already
2083          * started and we're just deserializing */
2084         if (m->n_reloading > 0)
2085                 return;
2086
2087         if (m->running_as != SYSTEMD_SYSTEM)
2088                 return;
2089
2090         if (u->type != UNIT_SERVICE)
2091                 return;
2092
2093         p = unit_name_to_prefix_and_instance(u->id);
2094         if (!p) {
2095                 log_oom();
2096                 return;
2097         }
2098
2099         msg = strappenda("unit=", p);
2100
2101         if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2102                 if (errno == EPERM)
2103                         /* We aren't allowed to send audit messages?
2104                          * Then let's not retry again. */
2105                         close_audit_fd();
2106                 else
2107                         log_warning_errno(errno, "Failed to send audit message: %m");
2108         }
2109 #endif
2110
2111 }
2112
2113 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2114         union sockaddr_union sa = PLYMOUTH_SOCKET;
2115
2116         int n = 0;
2117         _cleanup_free_ char *message = NULL;
2118         _cleanup_close_ int fd = -1;
2119
2120         /* Don't generate plymouth events if the service was already
2121          * started and we're just deserializing */
2122         if (m->n_reloading > 0)
2123                 return;
2124
2125         if (m->running_as != SYSTEMD_SYSTEM)
2126                 return;
2127
2128         if (detect_container(NULL) > 0)
2129                 return;
2130
2131         if (u->type != UNIT_SERVICE &&
2132             u->type != UNIT_MOUNT &&
2133             u->type != UNIT_SWAP)
2134                 return;
2135
2136         /* We set SOCK_NONBLOCK here so that we rather drop the
2137          * message then wait for plymouth */
2138         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2139         if (fd < 0) {
2140                 log_error_errno(errno, "socket() failed: %m");
2141                 return;
2142         }
2143
2144         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2145
2146                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2147                         log_error_errno(errno, "connect() failed: %m");
2148                 return;
2149         }
2150
2151         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2152                 log_oom();
2153                 return;
2154         }
2155
2156         errno = 0;
2157         if (write(fd, message, n + 1) != n + 1)
2158                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2159                         log_error_errno(errno, "Failed to write Plymouth message: %m");
2160 }
2161
2162 void manager_dispatch_bus_name_owner_changed(
2163                 Manager *m,
2164                 const char *name,
2165                 const char* old_owner,
2166                 const char *new_owner) {
2167
2168         Unit *u;
2169
2170         assert(m);
2171         assert(name);
2172
2173         u = hashmap_get(m->watch_bus, name);
2174         if (!u)
2175                 return;
2176
2177         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2178 }
2179
2180 int manager_open_serialization(Manager *m, FILE **_f) {
2181         const char *path;
2182         int fd = -1;
2183         FILE *f;
2184
2185         assert(_f);
2186
2187         path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2188         fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2189         if (fd < 0)
2190                 return -errno;
2191
2192         log_debug("Serializing state to %s", path);
2193
2194         f = fdopen(fd, "w+");
2195         if (!f) {
2196                 safe_close(fd);
2197                 return -errno;
2198         }
2199
2200         *_f = f;
2201
2202         return 0;
2203 }
2204
2205 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2206         Iterator i;
2207         Unit *u;
2208         const char *t;
2209         char **e;
2210         int r;
2211
2212         assert(m);
2213         assert(f);
2214         assert(fds);
2215
2216         m->n_reloading ++;
2217
2218         fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2219         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2220         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2221         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2222
2223         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2224         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2225         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2226         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2227
2228         if (!in_initrd()) {
2229                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2230                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2231                 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2232                 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2233                 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2234                 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2235                 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2236                 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2237         }
2238
2239         if (!switching_root) {
2240                 STRV_FOREACH(e, m->environment) {
2241                         _cleanup_free_ char *ce;
2242
2243                         ce = cescape(*e);
2244                         if (!ce)
2245                                 return -ENOMEM;
2246
2247                         fprintf(f, "env=%s\n", *e);
2248                 }
2249         }
2250
2251         if (m->notify_fd >= 0) {
2252                 int copy;
2253
2254                 copy = fdset_put_dup(fds, m->notify_fd);
2255                 if (copy < 0)
2256                         return copy;
2257
2258                 fprintf(f, "notify-fd=%i\n", copy);
2259                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2260         }
2261
2262         if (m->kdbus_fd >= 0) {
2263                 int copy;
2264
2265                 copy = fdset_put_dup(fds, m->kdbus_fd);
2266                 if (copy < 0)
2267                         return copy;
2268
2269                 fprintf(f, "kdbus-fd=%i\n", copy);
2270         }
2271
2272         bus_track_serialize(m->subscribed, f);
2273
2274         fputc('\n', f);
2275
2276         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2277                 if (u->id != t)
2278                         continue;
2279
2280                 /* Start marker */
2281                 fputs(u->id, f);
2282                 fputc('\n', f);
2283
2284                 r = unit_serialize(u, f, fds, !switching_root);
2285                 if (r < 0) {
2286                         m->n_reloading --;
2287                         return r;
2288                 }
2289         }
2290
2291         assert(m->n_reloading > 0);
2292         m->n_reloading --;
2293
2294         if (ferror(f))
2295                 return -EIO;
2296
2297         r = bus_fdset_add_all(m, fds);
2298         if (r < 0)
2299                 return r;
2300
2301         return 0;
2302 }
2303
2304 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2305         int r = 0;
2306
2307         assert(m);
2308         assert(f);
2309
2310         log_debug("Deserializing state...");
2311
2312         m->n_reloading ++;
2313
2314         for (;;) {
2315                 char line[LINE_MAX], *l;
2316
2317                 if (!fgets(line, sizeof(line), f)) {
2318                         if (feof(f))
2319                                 r = 0;
2320                         else
2321                                 r = -errno;
2322
2323                         goto finish;
2324                 }
2325
2326                 char_array_0(line);
2327                 l = strstrip(line);
2328
2329                 if (l[0] == 0)
2330                         break;
2331
2332                 if (startswith(l, "current-job-id=")) {
2333                         uint32_t id;
2334
2335                         if (safe_atou32(l+15, &id) < 0)
2336                                 log_debug("Failed to parse current job id value %s", l+15);
2337                         else
2338                                 m->current_job_id = MAX(m->current_job_id, id);
2339
2340                 } else if (startswith(l, "n-installed-jobs=")) {
2341                         uint32_t n;
2342
2343                         if (safe_atou32(l+17, &n) < 0)
2344                                 log_debug("Failed to parse installed jobs counter %s", l+17);
2345                         else
2346                                 m->n_installed_jobs += n;
2347
2348                 } else if (startswith(l, "n-failed-jobs=")) {
2349                         uint32_t n;
2350
2351                         if (safe_atou32(l+14, &n) < 0)
2352                                 log_debug("Failed to parse failed jobs counter %s", l+14);
2353                         else
2354                                 m->n_failed_jobs += n;
2355
2356                 } else if (startswith(l, "taint-usr=")) {
2357                         int b;
2358
2359                         b = parse_boolean(l+10);
2360                         if (b < 0)
2361                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2362                         else
2363                                 m->taint_usr = m->taint_usr || b;
2364
2365                 } else if (startswith(l, "firmware-timestamp="))
2366                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2367                 else if (startswith(l, "loader-timestamp="))
2368                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2369                 else if (startswith(l, "kernel-timestamp="))
2370                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2371                 else if (startswith(l, "initrd-timestamp="))
2372                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2373                 else if (startswith(l, "userspace-timestamp="))
2374                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2375                 else if (startswith(l, "finish-timestamp="))
2376                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2377                 else if (startswith(l, "security-start-timestamp="))
2378                         dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2379                 else if (startswith(l, "security-finish-timestamp="))
2380                         dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2381                 else if (startswith(l, "generators-start-timestamp="))
2382                         dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2383                 else if (startswith(l, "generators-finish-timestamp="))
2384                         dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2385                 else if (startswith(l, "units-load-start-timestamp="))
2386                         dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2387                 else if (startswith(l, "units-load-finish-timestamp="))
2388                         dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2389                 else if (startswith(l, "env=")) {
2390                         _cleanup_free_ char *uce = NULL;
2391                         char **e;
2392
2393                         uce = cunescape(l+4);
2394                         if (!uce) {
2395                                 r = -ENOMEM;
2396                                 goto finish;
2397                         }
2398
2399                         e = strv_env_set(m->environment, uce);
2400                         if (!e) {
2401                                 r = -ENOMEM;
2402                                 goto finish;
2403                         }
2404
2405                         strv_free(m->environment);
2406                         m->environment = e;
2407
2408                 } else if (startswith(l, "notify-fd=")) {
2409                         int fd;
2410
2411                         if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2412                                 log_debug("Failed to parse notify fd: %s", l + 10);
2413                         else {
2414                                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2415                                 safe_close(m->notify_fd);
2416                                 m->notify_fd = fdset_remove(fds, fd);
2417                         }
2418
2419                 } else if (startswith(l, "notify-socket=")) {
2420                         char *n;
2421
2422                         n = strdup(l+14);
2423                         if (!n) {
2424                                 r = -ENOMEM;
2425                                 goto finish;
2426                         }
2427
2428                         free(m->notify_socket);
2429                         m->notify_socket = n;
2430
2431                 } else if (startswith(l, "kdbus-fd=")) {
2432                         int fd;
2433
2434                         if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2435                                 log_debug("Failed to parse kdbus fd: %s", l + 9);
2436                         else {
2437                                 safe_close(m->kdbus_fd);
2438                                 m->kdbus_fd = fdset_remove(fds, fd);
2439                         }
2440
2441                 } else {
2442                         int k;
2443
2444                         k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2445                         if (k < 0)
2446                                 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2447                         else if (k == 0)
2448                                 log_debug("Unknown serialization item '%s'", l);
2449                 }
2450         }
2451
2452         for (;;) {
2453                 Unit *u;
2454                 char name[UNIT_NAME_MAX+2];
2455
2456                 /* Start marker */
2457                 if (!fgets(name, sizeof(name), f)) {
2458                         if (feof(f))
2459                                 r = 0;
2460                         else
2461                                 r = -errno;
2462
2463                         goto finish;
2464                 }
2465
2466                 char_array_0(name);
2467
2468                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2469                 if (r < 0)
2470                         goto finish;
2471
2472                 r = unit_deserialize(u, f, fds);
2473                 if (r < 0)
2474                         goto finish;
2475         }
2476
2477 finish:
2478         if (ferror(f))
2479                 r = -EIO;
2480
2481         assert(m->n_reloading > 0);
2482         m->n_reloading --;
2483
2484         return r;
2485 }
2486
2487 int manager_reload(Manager *m) {
2488         int r, q;
2489         _cleanup_fclose_ FILE *f = NULL;
2490         _cleanup_fdset_free_ FDSet *fds = NULL;
2491
2492         assert(m);
2493
2494         r = manager_open_serialization(m, &f);
2495         if (r < 0)
2496                 return r;
2497
2498         m->n_reloading ++;
2499         bus_manager_send_reloading(m, true);
2500
2501         fds = fdset_new();
2502         if (!fds) {
2503                 m->n_reloading --;
2504                 return -ENOMEM;
2505         }
2506
2507         r = manager_serialize(m, f, fds, false);
2508         if (r < 0) {
2509                 m->n_reloading --;
2510                 return r;
2511         }
2512
2513         if (fseeko(f, 0, SEEK_SET) < 0) {
2514                 m->n_reloading --;
2515                 return -errno;
2516         }
2517
2518         /* From here on there is no way back. */
2519         manager_clear_jobs_and_units(m);
2520         manager_undo_generators(m);
2521         lookup_paths_free(&m->lookup_paths);
2522
2523         /* Find new unit paths */
2524         q = manager_run_generators(m);
2525         if (q < 0 && r >= 0)
2526                 r = q;
2527
2528         q = lookup_paths_init(
2529                         &m->lookup_paths, m->running_as, true,
2530                         NULL,
2531                         m->generator_unit_path,
2532                         m->generator_unit_path_early,
2533                         m->generator_unit_path_late);
2534         if (q < 0 && r >= 0)
2535                 r = q;
2536
2537         manager_build_unit_path_cache(m);
2538
2539         /* First, enumerate what we can from all config files */
2540         q = manager_enumerate(m);
2541         if (q < 0 && r >= 0)
2542                 r = q;
2543
2544         /* Second, deserialize our stored data */
2545         q = manager_deserialize(m, f, fds);
2546         if (q < 0 && r >= 0)
2547                 r = q;
2548
2549         fclose(f);
2550         f = NULL;
2551
2552         /* Re-register notify_fd as event source */
2553         q = manager_setup_notify(m);
2554         if (q < 0 && r >= 0)
2555                 r = q;
2556
2557         /* Third, fire things up! */
2558         q = manager_coldplug(m);
2559         if (q < 0 && r >= 0)
2560                 r = q;
2561
2562         assert(m->n_reloading > 0);
2563         m->n_reloading--;
2564
2565         m->send_reloading_done = true;
2566
2567         return r;
2568 }
2569
2570 bool manager_is_reloading_or_reexecuting(Manager *m) {
2571         assert(m);
2572
2573         return m->n_reloading != 0;
2574 }
2575
2576 void manager_reset_failed(Manager *m) {
2577         Unit *u;
2578         Iterator i;
2579
2580         assert(m);
2581
2582         HASHMAP_FOREACH(u, m->units, i)
2583                 unit_reset_failed(u);
2584 }
2585
2586 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2587         Unit *u;
2588
2589         assert(m);
2590         assert(name);
2591
2592         /* Returns true if the unit is inactive or going down */
2593         u = manager_get_unit(m, name);
2594         if (!u)
2595                 return true;
2596
2597         return unit_inactive_or_pending(u);
2598 }
2599
2600 static void manager_notify_finished(Manager *m) {
2601         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2602         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2603
2604         if (m->test_run)
2605                 return;
2606
2607         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2608
2609                 /* Note that m->kernel_usec.monotonic is always at 0,
2610                  * and m->firmware_usec.monotonic and
2611                  * m->loader_usec.monotonic should be considered
2612                  * negative values. */
2613
2614                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2615                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2616                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2617                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2618
2619                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2620
2621                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2622                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2623
2624                         log_struct(LOG_INFO,
2625                                    LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2626                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2627                                    "INITRD_USEC="USEC_FMT, initrd_usec,
2628                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2629                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2630                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2631                                                format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2632                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2633                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2634                                    NULL);
2635                 } else {
2636                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2637                         initrd_usec = 0;
2638
2639                         log_struct(LOG_INFO,
2640                                    LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2641                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2642                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2643                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2644                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2645                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2646                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2647                                    NULL);
2648                 }
2649         } else {
2650                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2651                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2652
2653                 log_struct(LOG_INFO,
2654                            LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2655                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2656                            LOG_MESSAGE("Startup finished in %s.",
2657                                        format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2658                            NULL);
2659         }
2660
2661         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2662
2663         sd_notifyf(false,
2664                    "READY=1\n"
2665                    "STATUS=Startup finished in %s.",
2666                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2667 }
2668
2669 void manager_check_finished(Manager *m) {
2670         Unit *u = NULL;
2671         Iterator i;
2672
2673         assert(m);
2674
2675         if (hashmap_size(m->jobs) > 0) {
2676
2677                 if (m->jobs_in_progress_event_source)
2678                         sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2679
2680                 return;
2681         }
2682
2683         manager_flip_auto_status(m, false);
2684
2685         /* Notify Type=idle units that we are done now */
2686         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2687         manager_close_idle_pipe(m);
2688
2689         /* Turn off confirm spawn now */
2690         m->confirm_spawn = false;
2691
2692         /* No need to update ask password status when we're going non-interactive */
2693         manager_close_ask_password(m);
2694
2695         /* This is no longer the first boot */
2696         manager_set_first_boot(m, false);
2697
2698         if (dual_timestamp_is_set(&m->finish_timestamp))
2699                 return;
2700
2701         dual_timestamp_get(&m->finish_timestamp);
2702
2703         manager_notify_finished(m);
2704
2705         SET_FOREACH(u, m->startup_units, i)
2706                 if (u->cgroup_path)
2707                         cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2708 }
2709
2710 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2711         char *p;
2712         int r;
2713
2714         assert(m);
2715         assert(generator);
2716         assert(name);
2717
2718         if (*generator)
2719                 return 0;
2720
2721         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2722                 /* systemd --system, not running --test */
2723
2724                 p = strappend("/run/systemd/", name);
2725                 if (!p)
2726                         return log_oom();
2727
2728                 r = mkdir_p_label(p, 0755);
2729                 if (r < 0) {
2730                         log_error_errno(r, "Failed to create generator directory %s: %m", p);
2731                         free(p);
2732                         return r;
2733                 }
2734         } else if (m->running_as == SYSTEMD_USER) {
2735                 const char *s = NULL;
2736
2737                 s = getenv("XDG_RUNTIME_DIR");
2738                 if (!s)
2739                         return -EINVAL;
2740                 p = strjoin(s, "/systemd/", name, NULL);
2741                 if (!p)
2742                         return log_oom();
2743
2744                 r = mkdir_p_label(p, 0755);
2745                 if (r < 0) {
2746                         log_error_errno(r, "Failed to create generator directory %s: %m", p);
2747                         free(p);
2748                         return r;
2749                 }
2750         } else {
2751                 /* systemd --system --test */
2752
2753                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2754                 if (!p)
2755                         return log_oom();
2756
2757                 if (!mkdtemp(p)) {
2758                         log_error_errno(errno, "Failed to create generator directory %s: %m",
2759                                   p);
2760                         free(p);
2761                         return -errno;
2762                 }
2763         }
2764
2765         *generator = p;
2766         return 0;
2767 }
2768
2769 static void trim_generator_dir(Manager *m, char **generator) {
2770         assert(m);
2771         assert(generator);
2772
2773         if (!*generator)
2774                 return;
2775
2776         if (rmdir(*generator) >= 0) {
2777                 free(*generator);
2778                 *generator = NULL;
2779         }
2780
2781         return;
2782 }
2783
2784 static int manager_run_generators(Manager *m) {
2785         _cleanup_free_ char **paths = NULL;
2786         const char *argv[5];
2787         char **path;
2788         int r;
2789
2790         assert(m);
2791
2792         if (m->test_run)
2793                 return 0;
2794
2795         paths = generator_paths(m->running_as);
2796         if (!paths)
2797                 return log_oom();
2798
2799         /* Optimize by skipping the whole process by not creating output directories
2800          * if no generators are found. */
2801         STRV_FOREACH(path, paths) {
2802                 r = access(*path, F_OK);
2803                 if (r == 0)
2804                         goto found;
2805                 if (errno != ENOENT)
2806                         log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
2807         }
2808         return 0;
2809
2810  found:
2811         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2812         if (r < 0)
2813                 goto finish;
2814
2815         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2816         if (r < 0)
2817                 goto finish;
2818
2819         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2820         if (r < 0)
2821                 goto finish;
2822
2823         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2824         argv[1] = m->generator_unit_path;
2825         argv[2] = m->generator_unit_path_early;
2826         argv[3] = m->generator_unit_path_late;
2827         argv[4] = NULL;
2828
2829         RUN_WITH_UMASK(0022)
2830                 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
2831
2832 finish:
2833         trim_generator_dir(m, &m->generator_unit_path);
2834         trim_generator_dir(m, &m->generator_unit_path_early);
2835         trim_generator_dir(m, &m->generator_unit_path_late);
2836         return r;
2837 }
2838
2839 static void remove_generator_dir(Manager *m, char **generator) {
2840         assert(m);
2841         assert(generator);
2842
2843         if (!*generator)
2844                 return;
2845
2846         strv_remove(m->lookup_paths.unit_path, *generator);
2847         rm_rf(*generator, false, true, false);
2848
2849         free(*generator);
2850         *generator = NULL;
2851 }
2852
2853 static void manager_undo_generators(Manager *m) {
2854         assert(m);
2855
2856         remove_generator_dir(m, &m->generator_unit_path);
2857         remove_generator_dir(m, &m->generator_unit_path_early);
2858         remove_generator_dir(m, &m->generator_unit_path_late);
2859 }
2860
2861 int manager_environment_add(Manager *m, char **minus, char **plus) {
2862         char **a = NULL, **b = NULL, **l;
2863         assert(m);
2864
2865         l = m->environment;
2866
2867         if (!strv_isempty(minus)) {
2868                 a = strv_env_delete(l, 1, minus);
2869                 if (!a)
2870                         return -ENOMEM;
2871
2872                 l = a;
2873         }
2874
2875         if (!strv_isempty(plus)) {
2876                 b = strv_env_merge(2, l, plus);
2877                 if (!b) {
2878                         strv_free(a);
2879                         return -ENOMEM;
2880                 }
2881
2882                 l = b;
2883         }
2884
2885         if (m->environment != l)
2886                 strv_free(m->environment);
2887         if (a != l)
2888                 strv_free(a);
2889         if (b != l)
2890                 strv_free(b);
2891
2892         m->environment = l;
2893         manager_clean_environment(m);
2894         strv_sort(m->environment);
2895
2896         return 0;
2897 }
2898
2899 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2900         int i;
2901
2902         assert(m);
2903
2904         for (i = 0; i < _RLIMIT_MAX; i++) {
2905                 if (!default_rlimit[i])
2906                         continue;
2907
2908                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2909                 if (!m->rlimit[i])
2910                         return -ENOMEM;
2911         }
2912
2913         return 0;
2914 }
2915
2916 void manager_recheck_journal(Manager *m) {
2917         Unit *u;
2918
2919         assert(m);
2920
2921         if (m->running_as != SYSTEMD_SYSTEM)
2922                 return;
2923
2924         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2925         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2926                 log_close_journal();
2927                 return;
2928         }
2929
2930         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2931         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2932                 log_close_journal();
2933                 return;
2934         }
2935
2936         /* Hmm, OK, so the socket is fully up and the service is up
2937          * too, then let's make use of the thing. */
2938         log_open();
2939 }
2940
2941 void manager_set_show_status(Manager *m, ShowStatus mode) {
2942         assert(m);
2943         assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2944
2945         if (m->running_as != SYSTEMD_SYSTEM)
2946                 return;
2947
2948         m->show_status = mode;
2949
2950         if (mode > 0)
2951                 touch("/run/systemd/show-status");
2952         else
2953                 unlink("/run/systemd/show-status");
2954 }
2955
2956 static bool manager_get_show_status(Manager *m, StatusType type) {
2957         assert(m);
2958
2959         if (m->running_as != SYSTEMD_SYSTEM)
2960                 return false;
2961
2962         if (m->no_console_output)
2963                 return false;
2964
2965         if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2966                 return false;
2967
2968         /* If we cannot find out the status properly, just proceed. */
2969         if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2970                 return false;
2971
2972         if (m->show_status > 0)
2973                 return true;
2974
2975         /* If Plymouth is running make sure we show the status, so
2976          * that there's something nice to see when people press Esc */
2977         return plymouth_running();
2978 }
2979
2980 void manager_set_first_boot(Manager *m, bool b) {
2981         assert(m);
2982
2983         if (m->running_as != SYSTEMD_SYSTEM)
2984                 return;
2985
2986         m->first_boot = b;
2987
2988         if (m->first_boot)
2989                 touch("/run/systemd/first-boot");
2990         else
2991                 unlink("/run/systemd/first-boot");
2992 }
2993
2994 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
2995         va_list ap;
2996
2997         /* If m is NULL, assume we're after shutdown and let the messages through. */
2998
2999         if (m && !manager_get_show_status(m, type))
3000                 return;
3001
3002         /* XXX We should totally drop the check for ephemeral here
3003          * and thus effectively make 'Type=idle' pointless. */
3004         if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3005                 return;
3006
3007         va_start(ap, format);
3008         status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3009         va_end(ap);
3010 }
3011
3012 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
3013         _cleanup_free_ char *p = NULL;
3014         Unit *found;
3015
3016         assert(m);
3017         assert(path);
3018         assert(suffix);
3019         assert(_found);
3020
3021         p = unit_name_from_path(path, suffix);
3022         if (!p)
3023                 return -ENOMEM;
3024
3025         found = manager_get_unit(m, p);
3026         if (!found) {
3027                 *_found = NULL;
3028                 return 0;
3029         }
3030
3031         *_found = found;
3032         return 1;
3033 }
3034
3035 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3036         char p[strlen(path)+1];
3037
3038         assert(m);
3039         assert(path);
3040
3041         strcpy(p, path);
3042         path_kill_slashes(p);
3043
3044         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3045 }
3046
3047 const char *manager_get_runtime_prefix(Manager *m) {
3048         assert(m);
3049
3050         return m->running_as == SYSTEMD_SYSTEM ?
3051                "/run" :
3052                getenv("XDG_RUNTIME_DIR");
3053 }
3054
3055 ManagerState manager_state(Manager *m) {
3056         Unit *u;
3057
3058         assert(m);
3059
3060         /* Did we ever finish booting? If not then we are still starting up */
3061         if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3062
3063                 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3064                 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3065                         return MANAGER_INITIALIZING;
3066
3067                 return MANAGER_STARTING;
3068         }
3069
3070         /* Is the special shutdown target queued? If so, we are in shutdown state */
3071         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3072         if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3073                 return MANAGER_STOPPING;
3074
3075         /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3076         u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3077         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3078                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3079                 return MANAGER_MAINTENANCE;
3080
3081         u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3082         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3083                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3084                 return MANAGER_MAINTENANCE;
3085
3086         /* Are there any failed units? If so, we are in degraded mode */
3087         if (set_size(m->failed_units) > 0)
3088                 return MANAGER_DEGRADED;
3089
3090         return MANAGER_RUNNING;
3091 }
3092
3093 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3094         [MANAGER_INITIALIZING] = "initializing",
3095         [MANAGER_STARTING] = "starting",
3096         [MANAGER_RUNNING] = "running",
3097         [MANAGER_DEGRADED] = "degraded",
3098         [MANAGER_MAINTENANCE] = "maintenance",
3099         [MANAGER_STOPPING] = "stopping",
3100 };
3101
3102 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);