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