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