src/core/manager.c

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