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                         if (u->id)
 842                                 log_unit_debug(u->id, "Collecting %s", u->id);
 843                         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 844                         unit_add_to_cleanup_queue(u);
 845                 }
 846         }
 847
 848         m->n_in_gc_queue = 0;
 849
 850         return n;
 851 }
 852
 853 static void manager_clear_jobs_and_units(Manager *m) {
 854         Unit *u;
 855
 856         assert(m);
 857
 858         while ((u = hashmap_first(m->units)))
 859                 unit_free(u);
 860
 861         manager_dispatch_cleanup_queue(m);
 862
 863         assert(!m->load_queue);
 864         assert(!m->run_queue);
 865         assert(!m->dbus_unit_queue);
 866         assert(!m->dbus_job_queue);
 867         assert(!m->cleanup_queue);
 868         assert(!m->gc_queue);
 869
 870         assert(hashmap_isempty(m->jobs));
 871         assert(hashmap_isempty(m->units));
 872
 873         m->n_on_console = 0;
 874         m->n_running_jobs = 0;
 875 }
 876
 877 Manager* manager_free(Manager *m) {
 878         UnitType c;
 879         int i;
 880
 881         if (!m)
 882                 return NULL;
 883
 884         manager_clear_jobs_and_units(m);
 885
 886         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 887                 if (unit_vtable[c]->shutdown)
 888                         unit_vtable[c]->shutdown(m);
 889
 890         /* If we reexecute ourselves, we keep the root cgroup
 891          * around */
 892         manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
 893
 894         manager_undo_generators(m);
 895
 896         bus_done(m);
 897
 898         hashmap_free(m->units);
 899         hashmap_free(m->jobs);
 900         hashmap_free(m->watch_pids1);
 901         hashmap_free(m->watch_pids2);
 902         hashmap_free(m->watch_bus);
 903
 904         set_free(m->startup_units);
 905         set_free(m->failed_units);
 906
 907         sd_event_source_unref(m->signal_event_source);
 908         sd_event_source_unref(m->notify_event_source);
 909         sd_event_source_unref(m->time_change_event_source);
 910         sd_event_source_unref(m->jobs_in_progress_event_source);
 911         sd_event_source_unref(m->idle_pipe_event_source);
 912         sd_event_source_unref(m->run_queue_event_source);
 913
 914         safe_close(m->signal_fd);
 915         safe_close(m->notify_fd);
 916         safe_close(m->time_change_fd);
 917         safe_close(m->kdbus_fd);
 918
 919         manager_close_ask_password(m);
 920
 921         manager_close_idle_pipe(m);
 922
 923         udev_unref(m->udev);
 924         sd_event_unref(m->event);
 925
 926         free(m->notify_socket);
 927
 928         lookup_paths_free(&m->lookup_paths);
 929         strv_free(m->environment);
 930
 931         hashmap_free(m->cgroup_unit);
 932         set_free_free(m->unit_path_cache);
 933
 934         free(m->switch_root);
 935         free(m->switch_root_init);
 936
 937         for (i = 0; i < _RLIMIT_MAX; i++)
 938                 free(m->rlimit[i]);
 939
 940         assert(hashmap_isempty(m->units_requiring_mounts_for));
 941         hashmap_free(m->units_requiring_mounts_for);
 942
 943         free(m);
 944         return NULL;
 945 }
 946
 947 int manager_enumerate(Manager *m) {
 948         int r = 0;
 949         UnitType c;
 950
 951         assert(m);
 952
 953         /* Let's ask every type to load all units from disk/kernel
 954          * that it might know */
 955         for (c = 0; c < _UNIT_TYPE_MAX; c++) {
 956                 int q;
 957
 958                 if (unit_vtable[c]->supported && !unit_vtable[c]->supported(m)) {
 959                         log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
 960                         continue;
 961                 }
 962
 963                 if (!unit_vtable[c]->enumerate)
 964                         continue;
 965
 966                 q = unit_vtable[c]->enumerate(m);
 967                 if (q < 0)
 968                         r = q;
 969         }
 970
 971         manager_dispatch_load_queue(m);
 972         return r;
 973 }
 974
 975 static int manager_coldplug(Manager *m) {
 976         int r = 0;
 977         Iterator i;
 978         Unit *u;
 979         char *k;
 980
 981         /*
 982          * Some unit types tend to spawn jobs or check other units' state
 983          * during coldplug. This is wrong because it is undefined whether the
 984          * units in question have been already coldplugged (i. e. their state
 985          * restored). This way, we can easily re-start an already started unit
 986          * or otherwise make a wrong decision based on the unit's state.
 987          *
 988          * Solve this by providing a way for coldplug functions to defer
 989          * such actions until after all units have been coldplugged.
 990          *
 991          * We store Unit* -> int(*)(Unit*).
 992          *
 993          * https://bugs.freedesktop.org/show_bug.cgi?id=88401
 994          */
 995         _cleanup_hashmap_free_ Hashmap *deferred_work = NULL;
 996         int(*proc)(Unit*);
 997
 998         assert(m);
 999
1000         deferred_work = hashmap_new(&trivial_hash_ops);
1001         if (!deferred_work)
1002                 return -ENOMEM;
1003
1004         /* Then, let's set up their initial state. */
1005         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1006                 int q;
1007
1008                 /* ignore aliases */
1009                 if (u->id != k)
1010                         continue;
1011
1012                 q = unit_coldplug(u, deferred_work);
1013                 if (q < 0)
1014                         r = q;
1015         }
1016
1017         /* After coldplugging and setting up initial state of the units,
1018          * let's perform operations which spawn jobs or query units' state. */
1019         HASHMAP_FOREACH_KEY(proc, u, deferred_work, i) {
1020                 int q;
1021
1022                 q = proc(u);
1023                 if (q < 0)
1024                         r = q;
1025         }
1026
1027         return r;
1028 }
1029
1030 static void manager_build_unit_path_cache(Manager *m) {
1031         char **i;
1032         _cleanup_closedir_ DIR *d = NULL;
1033         int r;
1034
1035         assert(m);
1036
1037         set_free_free(m->unit_path_cache);
1038
1039         m->unit_path_cache = set_new(&string_hash_ops);
1040         if (!m->unit_path_cache) {
1041                 log_error("Failed to allocate unit path cache.");
1042                 return;
1043         }
1044
1045         /* This simply builds a list of files we know exist, so that
1046          * we don't always have to go to disk */
1047
1048         STRV_FOREACH(i, m->lookup_paths.unit_path) {
1049                 struct dirent *de;
1050
1051                 d = opendir(*i);
1052                 if (!d) {
1053                         if (errno != ENOENT)
1054                                 log_error_errno(errno, "Failed to open directory %s: %m", *i);
1055                         continue;
1056                 }
1057
1058                 while ((de = readdir(d))) {
1059                         char *p;
1060
1061                         if (hidden_file(de->d_name))
1062                                 continue;
1063
1064                         p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
1065                         if (!p) {
1066                                 r = -ENOMEM;
1067                                 goto fail;
1068                         }
1069
1070                         r = set_consume(m->unit_path_cache, p);
1071                         if (r < 0)
1072                                 goto fail;
1073                 }
1074
1075                 closedir(d);
1076                 d = NULL;
1077         }
1078
1079         return;
1080
1081 fail:
1082         log_error_errno(r, "Failed to build unit path cache: %m");
1083
1084         set_free_free(m->unit_path_cache);
1085         m->unit_path_cache = NULL;
1086 }
1087
1088
1089 static int manager_distribute_fds(Manager *m, FDSet *fds) {
1090         Unit *u;
1091         Iterator i;
1092         int r;
1093
1094         assert(m);
1095
1096         HASHMAP_FOREACH(u, m->units, i) {
1097
1098                 if (fdset_size(fds) <= 0)
1099                         break;
1100
1101                 if (UNIT_VTABLE(u)->distribute_fds) {
1102                         r = UNIT_VTABLE(u)->distribute_fds(u, fds);
1103                         if (r < 0)
1104                                 return r;
1105                 }
1106         }
1107
1108         return 0;
1109 }
1110
1111 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1112         int r, q;
1113
1114         assert(m);
1115
1116         dual_timestamp_get(&m->generators_start_timestamp);
1117         r = manager_run_generators(m);
1118         dual_timestamp_get(&m->generators_finish_timestamp);
1119         if (r < 0)
1120                 return r;
1121
1122         r = lookup_paths_init(
1123                         &m->lookup_paths, m->running_as, true,
1124                         NULL,
1125                         m->generator_unit_path,
1126                         m->generator_unit_path_early,
1127                         m->generator_unit_path_late);
1128         if (r < 0)
1129                 return r;
1130
1131         manager_build_unit_path_cache(m);
1132
1133         /* If we will deserialize make sure that during enumeration
1134          * this is already known, so we increase the counter here
1135          * already */
1136         if (serialization)
1137                 m->n_reloading ++;
1138
1139         /* First, enumerate what we can from all config files */
1140         dual_timestamp_get(&m->units_load_start_timestamp);
1141         r = manager_enumerate(m);
1142         dual_timestamp_get(&m->units_load_finish_timestamp);
1143
1144         /* Second, deserialize if there is something to deserialize */
1145         if (serialization)
1146                 r = manager_deserialize(m, serialization, fds);
1147
1148         /* Any fds left? Find some unit which wants them. This is
1149          * useful to allow container managers to pass some file
1150          * descriptors to us pre-initialized. This enables
1151          * socket-based activation of entire containers. */
1152         if (fdset_size(fds) > 0) {
1153                 q = manager_distribute_fds(m, fds);
1154                 if (q < 0 && r == 0)
1155                         r = q;
1156         }
1157
1158         /* We might have deserialized the notify fd, but if we didn't
1159          * then let's create the bus now */
1160         q = manager_setup_notify(m);
1161         if (q < 0 && r == 0)
1162                 r = q;
1163
1164         /* We might have deserialized the kdbus control fd, but if we
1165          * didn't, then let's create the bus now. */
1166         manager_setup_kdbus(m);
1167         manager_connect_bus(m, !!serialization);
1168         bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1169
1170         /* Third, fire things up! */
1171         q = manager_coldplug(m);
1172         if (q < 0 && r == 0)
1173                 r = q;
1174
1175         if (serialization) {
1176                 assert(m->n_reloading > 0);
1177                 m->n_reloading --;
1178
1179                 /* Let's wait for the UnitNew/JobNew messages being
1180                  * sent, before we notify that the reload is
1181                  * finished */
1182                 m->send_reloading_done = true;
1183         }
1184
1185         return r;
1186 }
1187
1188 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1189         int r;
1190         Transaction *tr;
1191
1192         assert(m);
1193         assert(type < _JOB_TYPE_MAX);
1194         assert(unit);
1195         assert(mode < _JOB_MODE_MAX);
1196
1197         if (mode == JOB_ISOLATE && type != JOB_START)
1198                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1199
1200         if (mode == JOB_ISOLATE && !unit->allow_isolate)
1201                 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1202
1203         log_unit_debug(unit->id,
1204                        "Trying to enqueue job %s/%s/%s", unit->id,
1205                        job_type_to_string(type), job_mode_to_string(mode));
1206
1207         job_type_collapse(&type, unit);
1208
1209         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1210         if (!tr)
1211                 return -ENOMEM;
1212
1213         r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1214                                                  mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1215                                                  mode == JOB_IGNORE_DEPENDENCIES, e);
1216         if (r < 0)
1217                 goto tr_abort;
1218
1219         if (mode == JOB_ISOLATE) {
1220                 r = transaction_add_isolate_jobs(tr, m);
1221                 if (r < 0)
1222                         goto tr_abort;
1223         }
1224
1225         r = transaction_activate(tr, m, mode, e);
1226         if (r < 0)
1227                 goto tr_abort;
1228
1229         log_unit_debug(unit->id,
1230                        "Enqueued job %s/%s as %u", unit->id,
1231                        job_type_to_string(type), (unsigned) tr->anchor_job->id);
1232
1233         if (_ret)
1234                 *_ret = tr->anchor_job;
1235
1236         transaction_free(tr);
1237         return 0;
1238
1239 tr_abort:
1240         transaction_abort(tr);
1241         transaction_free(tr);
1242         return r;
1243 }
1244
1245 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1246         Unit *unit;
1247         int r;
1248
1249         assert(m);
1250         assert(type < _JOB_TYPE_MAX);
1251         assert(name);
1252         assert(mode < _JOB_MODE_MAX);
1253
1254         r = manager_load_unit(m, name, NULL, NULL, &unit);
1255         if (r < 0)
1256                 return r;
1257
1258         return manager_add_job(m, type, unit, mode, override, e, _ret);
1259 }
1260
1261 Job *manager_get_job(Manager *m, uint32_t id) {
1262         assert(m);
1263
1264         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1265 }
1266
1267 Unit *manager_get_unit(Manager *m, const char *name) {
1268         assert(m);
1269         assert(name);
1270
1271         return hashmap_get(m->units, name);
1272 }
1273
1274 unsigned manager_dispatch_load_queue(Manager *m) {
1275         Unit *u;
1276         unsigned n = 0;
1277
1278         assert(m);
1279
1280         /* Make sure we are not run recursively */
1281         if (m->dispatching_load_queue)
1282                 return 0;
1283
1284         m->dispatching_load_queue = true;
1285
1286         /* Dispatches the load queue. Takes a unit from the queue and
1287          * tries to load its data until the queue is empty */
1288
1289         while ((u = m->load_queue)) {
1290                 assert(u->in_load_queue);
1291
1292                 unit_load(u);
1293                 n++;
1294         }
1295
1296         m->dispatching_load_queue = false;
1297         return n;
1298 }
1299
1300 int manager_load_unit_prepare(
1301                 Manager *m,
1302                 const char *name,
1303                 const char *path,
1304                 sd_bus_error *e,
1305                 Unit **_ret) {
1306
1307         Unit *ret;
1308         UnitType t;
1309         int r;
1310
1311         assert(m);
1312         assert(name || path);
1313
1314         /* This will prepare the unit for loading, but not actually
1315          * load anything from disk. */
1316
1317         if (path && !is_path(path))
1318                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1319
1320         if (!name)
1321                 name = basename(path);
1322
1323         t = unit_name_to_type(name);
1324
1325         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1326                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1327
1328         ret = manager_get_unit(m, name);
1329         if (ret) {
1330                 *_ret = ret;
1331                 return 1;
1332         }
1333
1334         ret = unit_new(m, unit_vtable[t]->object_size);
1335         if (!ret)
1336                 return -ENOMEM;
1337
1338         if (path) {
1339                 ret->fragment_path = strdup(path);
1340                 if (!ret->fragment_path) {
1341                         unit_free(ret);
1342                         return -ENOMEM;
1343                 }
1344         }
1345
1346         r = unit_add_name(ret, name);
1347         if (r < 0) {
1348                 unit_free(ret);
1349                 return r;
1350         }
1351
1352         unit_add_to_load_queue(ret);
1353         unit_add_to_dbus_queue(ret);
1354         unit_add_to_gc_queue(ret);
1355
1356         if (_ret)
1357                 *_ret = ret;
1358
1359         return 0;
1360 }
1361
1362 int manager_load_unit(
1363                 Manager *m,
1364                 const char *name,
1365                 const char *path,
1366                 sd_bus_error *e,
1367                 Unit **_ret) {
1368
1369         int r;
1370
1371         assert(m);
1372
1373         /* This will load the service information files, but not actually
1374          * start any services or anything. */
1375
1376         r = manager_load_unit_prepare(m, name, path, e, _ret);
1377         if (r != 0)
1378                 return r;
1379
1380         manager_dispatch_load_queue(m);
1381
1382         if (_ret)
1383                 *_ret = unit_follow_merge(*_ret);
1384
1385         return 0;
1386 }
1387
1388 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1389         Iterator i;
1390         Job *j;
1391
1392         assert(s);
1393         assert(f);
1394
1395         HASHMAP_FOREACH(j, s->jobs, i)
1396                 job_dump(j, f, prefix);
1397 }
1398
1399 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1400         Iterator i;
1401         Unit *u;
1402         const char *t;
1403
1404         assert(s);
1405         assert(f);
1406
1407         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1408                 if (u->id == t)
1409                         unit_dump(u, f, prefix);
1410 }
1411
1412 void manager_clear_jobs(Manager *m) {
1413         Job *j;
1414
1415         assert(m);
1416
1417         while ((j = hashmap_first(m->jobs)))
1418                 /* No need to recurse. We're cancelling all jobs. */
1419                 job_finish_and_invalidate(j, JOB_CANCELED, false);
1420 }
1421
1422 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1423         Manager *m = userdata;
1424         Job *j;
1425
1426         assert(source);
1427         assert(m);
1428
1429         while ((j = m->run_queue)) {
1430                 assert(j->installed);
1431                 assert(j->in_run_queue);
1432
1433                 job_run_and_invalidate(j);
1434         }
1435
1436         if (m->n_running_jobs > 0)
1437                 manager_watch_jobs_in_progress(m);
1438
1439         if (m->n_on_console > 0)
1440                 manager_watch_idle_pipe(m);
1441
1442         return 1;
1443 }
1444
1445 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1446         Job *j;
1447         Unit *u;
1448         unsigned n = 0;
1449
1450         assert(m);
1451
1452         if (m->dispatching_dbus_queue)
1453                 return 0;
1454
1455         m->dispatching_dbus_queue = true;
1456
1457         while ((u = m->dbus_unit_queue)) {
1458                 assert(u->in_dbus_queue);
1459
1460                 bus_unit_send_change_signal(u);
1461                 n++;
1462         }
1463
1464         while ((j = m->dbus_job_queue)) {
1465                 assert(j->in_dbus_queue);
1466
1467                 bus_job_send_change_signal(j);
1468                 n++;
1469         }
1470
1471         m->dispatching_dbus_queue = false;
1472
1473         if (m->send_reloading_done) {
1474                 m->send_reloading_done = false;
1475
1476                 bus_manager_send_reloading(m, false);
1477         }
1478
1479         if (m->queued_message)
1480                 bus_send_queued_message(m);
1481
1482         return n;
1483 }
1484
1485 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n, FDSet *fds) {
1486         _cleanup_strv_free_ char **tags = NULL;
1487
1488         assert(m);
1489         assert(u);
1490         assert(buf);
1491         assert(n > 0);
1492
1493         tags = strv_split(buf, "\n\r");
1494         if (!tags) {
1495                 log_oom();
1496                 return;
1497         }
1498
1499         log_unit_debug(u->id, "Got notification message for unit %s", u->id);
1500
1501         if (UNIT_VTABLE(u)->notify_message)
1502                 UNIT_VTABLE(u)->notify_message(u, pid, tags, fds);
1503 }
1504
1505 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1506         Manager *m = userdata;
1507         ssize_t n;
1508         int r;
1509
1510         assert(m);
1511         assert(m->notify_fd == fd);
1512
1513         if (revents != EPOLLIN) {
1514                 log_warning("Got unexpected poll event for notify fd.");
1515                 return 0;
1516         }
1517
1518         for (;;) {
1519                 _cleanup_fdset_free_ FDSet *fds = NULL;
1520                 char buf[NOTIFY_BUFFER_MAX+1];
1521                 struct iovec iovec = {
1522                         .iov_base = buf,
1523                         .iov_len = sizeof(buf)-1,
1524                 };
1525                 union {
1526                         struct cmsghdr cmsghdr;
1527                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1528                                     CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1529                 } control = {};
1530                 struct msghdr msghdr = {
1531                         .msg_iov = &iovec,
1532                         .msg_iovlen = 1,
1533                         .msg_control = &control,
1534                         .msg_controllen = sizeof(control),
1535                 };
1536                 struct cmsghdr *cmsg;
1537                 struct ucred *ucred = NULL;
1538                 bool found = false;
1539                 Unit *u1, *u2, *u3;
1540                 int *fd_array = NULL;
1541                 unsigned n_fds = 0;
1542
1543                 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1544                 if (n < 0) {
1545                         if (errno == EAGAIN || errno == EINTR)
1546                                 break;
1547
1548                         return -errno;
1549                 }
1550
1551                 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1552                         if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1553
1554                                 fd_array = (int*) CMSG_DATA(cmsg);
1555                                 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1556
1557                         } else if (cmsg->cmsg_level == SOL_SOCKET &&
1558                                    cmsg->cmsg_type == SCM_CREDENTIALS &&
1559                                    cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1560
1561                                 ucred = (struct ucred*) CMSG_DATA(cmsg);
1562                         }
1563                 }
1564
1565                 if (n_fds > 0) {
1566                         assert(fd_array);
1567
1568                         r = fdset_new_array(&fds, fd_array, n_fds);
1569                         if (r < 0) {
1570                                 close_many(fd_array, n_fds);
1571                                 return log_oom();
1572                         }
1573                 }
1574
1575                 if (!ucred || ucred->pid <= 0) {
1576                         log_warning("Received notify message without valid credentials. Ignoring.");
1577                         continue;
1578                 }
1579
1580                 if ((size_t) n >= sizeof(buf)) {
1581                         log_warning("Received notify message exceeded maximum size. Ignoring.");
1582                         continue;
1583                 }
1584
1585                 buf[n] = 0;
1586
1587                 /* Notify every unit that might be interested, but try
1588                  * to avoid notifying the same one multiple times. */
1589                 u1 = manager_get_unit_by_pid(m, ucred->pid);
1590                 if (u1) {
1591                         manager_invoke_notify_message(m, u1, ucred->pid, buf, n, fds);
1592                         found = true;
1593                 }
1594
1595                 u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1596                 if (u2 && u2 != u1) {
1597                         manager_invoke_notify_message(m, u2, ucred->pid, buf, n, fds);
1598                         found = true;
1599                 }
1600
1601                 u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1602                 if (u3 && u3 != u2 && u3 != u1) {
1603                         manager_invoke_notify_message(m, u3, ucred->pid, buf, n, fds);
1604                         found = true;
1605                 }
1606
1607                 if (!found)
1608                         log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1609
1610                 if (fdset_size(fds) > 0)
1611                         log_warning("Got auxiliary fds with notification message, closing all.");
1612         }
1613
1614         return 0;
1615 }
1616
1617 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1618         assert(m);
1619         assert(u);
1620         assert(si);
1621
1622         log_unit_debug(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1623
1624         unit_unwatch_pid(u, si->si_pid);
1625         UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1626 }
1627
1628 static int manager_dispatch_sigchld(Manager *m) {
1629         assert(m);
1630
1631         for (;;) {
1632                 siginfo_t si = {};
1633
1634                 /* First we call waitd() for a PID and do not reap the
1635                  * zombie. That way we can still access /proc/$PID for
1636                  * it while it is a zombie. */
1637                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1638
1639                         if (errno == ECHILD)
1640                                 break;
1641
1642                         if (errno == EINTR)
1643                                 continue;
1644
1645                         return -errno;
1646                 }
1647
1648                 if (si.si_pid <= 0)
1649                         break;
1650
1651                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1652                         _cleanup_free_ char *name = NULL;
1653                         Unit *u1, *u2, *u3;
1654
1655                         get_process_comm(si.si_pid, &name);
1656
1657                         log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1658                                   si.si_pid, strna(name),
1659                                   sigchld_code_to_string(si.si_code),
1660                                   si.si_status,
1661                                   strna(si.si_code == CLD_EXITED
1662                                         ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1663                                         : signal_to_string(si.si_status)));
1664
1665                         /* And now figure out the unit this belongs
1666                          * to, it might be multiple... */
1667                         u1 = manager_get_unit_by_pid(m, si.si_pid);
1668                         if (u1)
1669                                 invoke_sigchld_event(m, u1, &si);
1670                         u2 = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1671                         if (u2 && u2 != u1)
1672                                 invoke_sigchld_event(m, u2, &si);
1673                         u3 = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1674                         if (u3 && u3 != u2 && u3 != u1)
1675                                 invoke_sigchld_event(m, u3, &si);
1676                 }
1677
1678                 /* And now, we actually reap the zombie. */
1679                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1680                         if (errno == EINTR)
1681                                 continue;
1682
1683                         return -errno;
1684                 }
1685         }
1686
1687         return 0;
1688 }
1689
1690 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1691         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1692         int r;
1693
1694         log_unit_debug(name, "Activating special unit %s", name);
1695
1696         r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1697         if (r < 0)
1698                 log_unit_error(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1699
1700         return r;
1701 }
1702
1703 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1704         Manager *m = userdata;
1705         ssize_t n;
1706         struct signalfd_siginfo sfsi;
1707         bool sigchld = false;
1708
1709         assert(m);
1710         assert(m->signal_fd == fd);
1711
1712         if (revents != EPOLLIN) {
1713                 log_warning("Got unexpected events from signal file descriptor.");
1714                 return 0;
1715         }
1716
1717         for (;;) {
1718                 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1719                 if (n != sizeof(sfsi)) {
1720
1721                         if (n >= 0)
1722                                 return -EIO;
1723
1724                         if (errno == EINTR || errno == EAGAIN)
1725                                 break;
1726
1727                         return -errno;
1728                 }
1729
1730                 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1731                                     (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1732                                     ? LOG_DEBUG : LOG_INFO,
1733                                     &sfsi);
1734
1735                 switch (sfsi.ssi_signo) {
1736
1737                 case SIGCHLD:
1738                         sigchld = true;
1739                         break;
1740
1741                 case SIGTERM:
1742                         if (m->running_as == SYSTEMD_SYSTEM) {
1743                                 /* This is for compatibility with the
1744                                  * original sysvinit */
1745                                 m->exit_code = MANAGER_REEXECUTE;
1746                                 break;
1747                         }
1748
1749                         /* Fall through */
1750
1751                 case SIGINT:
1752                         if (m->running_as == SYSTEMD_SYSTEM) {
1753
1754                                 /* If the user presses C-A-D more than
1755                                  * 7 times within 2s, we reboot
1756                                  * immediately. */
1757
1758                                 if (ratelimit_test(&m->ctrl_alt_del_ratelimit))
1759                                         manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1760                                 else {
1761                                         log_notice("Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1762                                         status_printf(NULL, true, false, "Ctrl-Alt-Del was pressed more than 7 times within 2s, rebooting immediately.");
1763                                         m->exit_code = MANAGER_REBOOT;
1764                                 }
1765
1766                                 break;
1767                         }
1768
1769                         /* Run the exit target if there is one, if not, just exit. */
1770                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1771                                 m->exit_code = MANAGER_EXIT;
1772                                 return 0;
1773                         }
1774
1775                         break;
1776
1777                 case SIGWINCH:
1778                         if (m->running_as == SYSTEMD_SYSTEM)
1779                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1780
1781                         /* This is a nop on non-init */
1782                         break;
1783
1784                 case SIGPWR:
1785                         if (m->running_as == SYSTEMD_SYSTEM)
1786                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1787
1788                         /* This is a nop on non-init */
1789                         break;
1790
1791                 case SIGUSR1: {
1792                         Unit *u;
1793
1794                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1795
1796                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1797                                 log_info("Trying to reconnect to bus...");
1798                                 bus_init(m, true);
1799                         }
1800
1801                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1802                                 log_info("Loading D-Bus service...");
1803                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1804                         }
1805
1806                         break;
1807                 }
1808
1809                 case SIGUSR2: {
1810                         _cleanup_free_ char *dump = NULL;
1811                         _cleanup_fclose_ FILE *f = NULL;
1812                         size_t size;
1813
1814                         f = open_memstream(&dump, &size);
1815                         if (!f) {
1816                                 log_warning("Failed to allocate memory stream.");
1817                                 break;
1818                         }
1819
1820                         manager_dump_units(m, f, "\t");
1821                         manager_dump_jobs(m, f, "\t");
1822
1823                         if (ferror(f)) {
1824                                 log_warning("Failed to write status stream");
1825                                 break;
1826                         }
1827
1828                         if (fflush(f)) {
1829                                 log_warning("Failed to flush status stream");
1830                                 break;
1831                         }
1832
1833                         log_dump(LOG_INFO, dump);
1834                         break;
1835                 }
1836
1837                 case SIGHUP:
1838                         m->exit_code = MANAGER_RELOAD;
1839                         break;
1840
1841                 default: {
1842
1843                         /* Starting SIGRTMIN+0 */
1844                         static const char * const target_table[] = {
1845                                 [0] = SPECIAL_DEFAULT_TARGET,
1846                                 [1] = SPECIAL_RESCUE_TARGET,
1847                                 [2] = SPECIAL_EMERGENCY_TARGET,
1848                                 [3] = SPECIAL_HALT_TARGET,
1849                                 [4] = SPECIAL_POWEROFF_TARGET,
1850                                 [5] = SPECIAL_REBOOT_TARGET,
1851                                 [6] = SPECIAL_KEXEC_TARGET
1852                         };
1853
1854                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1855                         static const ManagerExitCode code_table[] = {
1856                                 [0] = MANAGER_HALT,
1857                                 [1] = MANAGER_POWEROFF,
1858                                 [2] = MANAGER_REBOOT,
1859                                 [3] = MANAGER_KEXEC
1860                         };
1861
1862                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1863                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1864                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1865                                 manager_start_target(m, target_table[idx],
1866                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1867                                 break;
1868                         }
1869
1870                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1871                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1872                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1873                                 break;
1874                         }
1875
1876                         switch (sfsi.ssi_signo - SIGRTMIN) {
1877
1878                         case 20:
1879                                 log_debug("Enabling showing of status.");
1880                                 manager_set_show_status(m, SHOW_STATUS_YES);
1881                                 break;
1882
1883                         case 21:
1884                                 log_debug("Disabling showing of status.");
1885                                 manager_set_show_status(m, SHOW_STATUS_NO);
1886                                 break;
1887
1888                         case 22:
1889                                 log_set_max_level(LOG_DEBUG);
1890                                 log_notice("Setting log level to debug.");
1891                                 break;
1892
1893                         case 23:
1894                                 log_set_max_level(LOG_INFO);
1895                                 log_notice("Setting log level to info.");
1896                                 break;
1897
1898                         case 24:
1899                                 if (m->running_as == SYSTEMD_USER) {
1900                                         m->exit_code = MANAGER_EXIT;
1901                                         return 0;
1902                                 }
1903
1904                                 /* This is a nop on init */
1905                                 break;
1906
1907                         case 26:
1908                         case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
1909                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1910                                 log_notice("Setting log target to journal-or-kmsg.");
1911                                 break;
1912
1913                         case 27:
1914                                 log_set_target(LOG_TARGET_CONSOLE);
1915                                 log_notice("Setting log target to console.");
1916                                 break;
1917
1918                         case 28:
1919                                 log_set_target(LOG_TARGET_KMSG);
1920                                 log_notice("Setting log target to kmsg.");
1921                                 break;
1922
1923                         default:
1924                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1925                         }
1926                 }
1927                 }
1928         }
1929
1930         if (sigchld)
1931                 manager_dispatch_sigchld(m);
1932
1933         return 0;
1934 }
1935
1936 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1937         Manager *m = userdata;
1938         Iterator i;
1939         Unit *u;
1940
1941         assert(m);
1942         assert(m->time_change_fd == fd);
1943
1944         log_struct(LOG_INFO,
1945                    LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1946                    LOG_MESSAGE("Time has been changed"),
1947                    NULL);
1948
1949         /* Restart the watch */
1950         m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1951         m->time_change_fd = safe_close(m->time_change_fd);
1952
1953         manager_setup_time_change(m);
1954
1955         HASHMAP_FOREACH(u, m->units, i)
1956                 if (UNIT_VTABLE(u)->time_change)
1957                         UNIT_VTABLE(u)->time_change(u);
1958
1959         return 0;
1960 }
1961
1962 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1963         Manager *m = userdata;
1964
1965         assert(m);
1966         assert(m->idle_pipe[2] == fd);
1967
1968         m->no_console_output = m->n_on_console > 0;
1969
1970         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1971         manager_close_idle_pipe(m);
1972
1973         return 0;
1974 }
1975
1976 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1977         Manager *m = userdata;
1978         int r;
1979         uint64_t next;
1980
1981         assert(m);
1982         assert(source);
1983
1984         manager_print_jobs_in_progress(m);
1985
1986         next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1987         r = sd_event_source_set_time(source, next);
1988         if (r < 0)
1989                 return r;
1990
1991         return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1992 }
1993
1994 int manager_loop(Manager *m) {
1995         int r;
1996
1997         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1998
1999         assert(m);
2000         m->exit_code = MANAGER_OK;
2001
2002         /* Release the path cache */
2003         set_free_free(m->unit_path_cache);
2004         m->unit_path_cache = NULL;
2005
2006         manager_check_finished(m);
2007
2008         /* There might still be some zombies hanging around from
2009          * before we were exec()'ed. Let's reap them. */
2010         r = manager_dispatch_sigchld(m);
2011         if (r < 0)
2012                 return r;
2013
2014         while (m->exit_code == MANAGER_OK) {
2015                 usec_t wait_usec;
2016
2017                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
2018                         watchdog_ping();
2019
2020                 if (!ratelimit_test(&rl)) {
2021                         /* Yay, something is going seriously wrong, pause a little */
2022                         log_warning("Looping too fast. Throttling execution a little.");
2023                         sleep(1);
2024                         continue;
2025                 }
2026
2027                 if (manager_dispatch_load_queue(m) > 0)
2028                         continue;
2029
2030                 if (manager_dispatch_gc_queue(m) > 0)
2031                         continue;
2032
2033                 if (manager_dispatch_cleanup_queue(m) > 0)
2034                         continue;
2035
2036                 if (manager_dispatch_cgroup_queue(m) > 0)
2037                         continue;
2038
2039                 if (manager_dispatch_dbus_queue(m) > 0)
2040                         continue;
2041
2042                 /* Sleep for half the watchdog time */
2043                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
2044                         wait_usec = m->runtime_watchdog / 2;
2045                         if (wait_usec <= 0)
2046                                 wait_usec = 1;
2047                 } else
2048                         wait_usec = USEC_INFINITY;
2049
2050                 r = sd_event_run(m->event, wait_usec);
2051                 if (r < 0)
2052                         return log_error_errno(r, "Failed to run event loop: %m");
2053         }
2054
2055         return m->exit_code;
2056 }
2057
2058 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2059         _cleanup_free_ char *n = NULL;
2060         Unit *u;
2061         int r;
2062
2063         assert(m);
2064         assert(s);
2065         assert(_u);
2066
2067         r = unit_name_from_dbus_path(s, &n);
2068         if (r < 0)
2069                 return r;
2070
2071         r = manager_load_unit(m, n, NULL, e, &u);
2072         if (r < 0)
2073                 return r;
2074
2075         *_u = u;
2076
2077         return 0;
2078 }
2079
2080 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2081         const char *p;
2082         unsigned id;
2083         Job *j;
2084         int r;
2085
2086         assert(m);
2087         assert(s);
2088         assert(_j);
2089
2090         p = startswith(s, "/org/freedesktop/systemd1/job/");
2091         if (!p)
2092                 return -EINVAL;
2093
2094         r = safe_atou(p, &id);
2095         if (r < 0)
2096                 return r;
2097
2098         j = manager_get_job(m, id);
2099         if (!j)
2100                 return -ENOENT;
2101
2102         *_j = j;
2103
2104         return 0;
2105 }
2106
2107 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2108
2109 #ifdef HAVE_AUDIT
2110         _cleanup_free_ char *p = NULL;
2111         const char *msg;
2112         int audit_fd;
2113
2114         audit_fd = get_audit_fd();
2115         if (audit_fd < 0)
2116                 return;
2117
2118         /* Don't generate audit events if the service was already
2119          * started and we're just deserializing */
2120         if (m->n_reloading > 0)
2121                 return;
2122
2123         if (m->running_as != SYSTEMD_SYSTEM)
2124                 return;
2125
2126         if (u->type != UNIT_SERVICE)
2127                 return;
2128
2129         p = unit_name_to_prefix_and_instance(u->id);
2130         if (!p) {
2131                 log_oom();
2132                 return;
2133         }
2134
2135         msg = strjoina("unit=", p);
2136         if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2137                 if (errno == EPERM)
2138                         /* We aren't allowed to send audit messages?
2139                          * Then let's not retry again. */
2140                         close_audit_fd();
2141                 else
2142                         log_warning_errno(errno, "Failed to send audit message: %m");
2143         }
2144 #endif
2145
2146 }
2147
2148 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2149         union sockaddr_union sa = PLYMOUTH_SOCKET;
2150
2151         int n = 0;
2152         _cleanup_free_ char *message = NULL;
2153         _cleanup_close_ int fd = -1;
2154
2155         /* Don't generate plymouth events if the service was already
2156          * started and we're just deserializing */
2157         if (m->n_reloading > 0)
2158                 return;
2159
2160         if (m->running_as != SYSTEMD_SYSTEM)
2161                 return;
2162
2163         if (detect_container(NULL) > 0)
2164                 return;
2165
2166         if (u->type != UNIT_SERVICE &&
2167             u->type != UNIT_MOUNT &&
2168             u->type != UNIT_SWAP)
2169                 return;
2170
2171         /* We set SOCK_NONBLOCK here so that we rather drop the
2172          * message then wait for plymouth */
2173         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2174         if (fd < 0) {
2175                 log_error_errno(errno, "socket() failed: %m");
2176                 return;
2177         }
2178
2179         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2180
2181                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2182                         log_error_errno(errno, "connect() failed: %m");
2183                 return;
2184         }
2185
2186         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2187                 log_oom();
2188                 return;
2189         }
2190
2191         errno = 0;
2192         if (write(fd, message, n + 1) != n + 1)
2193                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2194                         log_error_errno(errno, "Failed to write Plymouth message: %m");
2195 }
2196
2197 void manager_dispatch_bus_name_owner_changed(
2198                 Manager *m,
2199                 const char *name,
2200                 const char* old_owner,
2201                 const char *new_owner) {
2202
2203         Unit *u;
2204
2205         assert(m);
2206         assert(name);
2207
2208         u = hashmap_get(m->watch_bus, name);
2209         if (!u)
2210                 return;
2211
2212         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2213 }
2214
2215 int manager_open_serialization(Manager *m, FILE **_f) {
2216         const char *path;
2217         int fd = -1;
2218         FILE *f;
2219
2220         assert(_f);
2221
2222         path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2223         fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2224         if (fd < 0)
2225                 return -errno;
2226
2227         log_debug("Serializing state to %s", path);
2228
2229         f = fdopen(fd, "w+");
2230         if (!f) {
2231                 safe_close(fd);
2232                 return -errno;
2233         }
2234
2235         *_f = f;
2236
2237         return 0;
2238 }
2239
2240 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2241         Iterator i;
2242         Unit *u;
2243         const char *t;
2244         char **e;
2245         int r;
2246
2247         assert(m);
2248         assert(f);
2249         assert(fds);
2250
2251         m->n_reloading ++;
2252
2253         fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2254         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2255         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2256         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2257
2258         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2259         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2260         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2261         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2262
2263         if (!in_initrd()) {
2264                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2265                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2266                 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2267                 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2268                 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2269                 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2270                 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2271                 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2272         }
2273
2274         if (!switching_root) {
2275                 STRV_FOREACH(e, m->environment) {
2276                         _cleanup_free_ char *ce;
2277
2278                         ce = cescape(*e);
2279                         if (!ce)
2280                                 return -ENOMEM;
2281
2282                         fprintf(f, "env=%s\n", *e);
2283                 }
2284         }
2285
2286         if (m->notify_fd >= 0) {
2287                 int copy;
2288
2289                 copy = fdset_put_dup(fds, m->notify_fd);
2290                 if (copy < 0)
2291                         return copy;
2292
2293                 fprintf(f, "notify-fd=%i\n", copy);
2294                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2295         }
2296
2297         if (m->kdbus_fd >= 0) {
2298                 int copy;
2299
2300                 copy = fdset_put_dup(fds, m->kdbus_fd);
2301                 if (copy < 0)
2302                         return copy;
2303
2304                 fprintf(f, "kdbus-fd=%i\n", copy);
2305         }
2306
2307         bus_track_serialize(m->subscribed, f);
2308
2309         fputc('\n', f);
2310
2311         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2312                 if (u->id != t)
2313                         continue;
2314
2315                 /* Start marker */
2316                 fputs(u->id, f);
2317                 fputc('\n', f);
2318
2319                 r = unit_serialize(u, f, fds, !switching_root);
2320                 if (r < 0) {
2321                         m->n_reloading --;
2322                         return r;
2323                 }
2324         }
2325
2326         assert(m->n_reloading > 0);
2327         m->n_reloading --;
2328
2329         if (ferror(f))
2330                 return -EIO;
2331
2332         r = bus_fdset_add_all(m, fds);
2333         if (r < 0)
2334                 return r;
2335
2336         return 0;
2337 }
2338
2339 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2340         int r = 0;
2341
2342         assert(m);
2343         assert(f);
2344
2345         log_debug("Deserializing state...");
2346
2347         m->n_reloading ++;
2348
2349         for (;;) {
2350                 char line[LINE_MAX], *l;
2351
2352                 if (!fgets(line, sizeof(line), f)) {
2353                         if (feof(f))
2354                                 r = 0;
2355                         else
2356                                 r = -errno;
2357
2358                         goto finish;
2359                 }
2360
2361                 char_array_0(line);
2362                 l = strstrip(line);
2363
2364                 if (l[0] == 0)
2365                         break;
2366
2367                 if (startswith(l, "current-job-id=")) {
2368                         uint32_t id;
2369
2370                         if (safe_atou32(l+15, &id) < 0)
2371                                 log_debug("Failed to parse current job id value %s", l+15);
2372                         else
2373                                 m->current_job_id = MAX(m->current_job_id, id);
2374
2375                 } else if (startswith(l, "n-installed-jobs=")) {
2376                         uint32_t n;
2377
2378                         if (safe_atou32(l+17, &n) < 0)
2379                                 log_debug("Failed to parse installed jobs counter %s", l+17);
2380                         else
2381                                 m->n_installed_jobs += n;
2382
2383                 } else if (startswith(l, "n-failed-jobs=")) {
2384                         uint32_t n;
2385
2386                         if (safe_atou32(l+14, &n) < 0)
2387                                 log_debug("Failed to parse failed jobs counter %s", l+14);
2388                         else
2389                                 m->n_failed_jobs += n;
2390
2391                 } else if (startswith(l, "taint-usr=")) {
2392                         int b;
2393
2394                         b = parse_boolean(l+10);
2395                         if (b < 0)
2396                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2397                         else
2398                                 m->taint_usr = m->taint_usr || b;
2399
2400                 } else if (startswith(l, "firmware-timestamp="))
2401                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2402                 else if (startswith(l, "loader-timestamp="))
2403                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2404                 else if (startswith(l, "kernel-timestamp="))
2405                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2406                 else if (startswith(l, "initrd-timestamp="))
2407                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2408                 else if (startswith(l, "userspace-timestamp="))
2409                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2410                 else if (startswith(l, "finish-timestamp="))
2411                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2412                 else if (startswith(l, "security-start-timestamp="))
2413                         dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2414                 else if (startswith(l, "security-finish-timestamp="))
2415                         dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2416                 else if (startswith(l, "generators-start-timestamp="))
2417                         dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2418                 else if (startswith(l, "generators-finish-timestamp="))
2419                         dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2420                 else if (startswith(l, "units-load-start-timestamp="))
2421                         dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2422                 else if (startswith(l, "units-load-finish-timestamp="))
2423                         dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2424                 else if (startswith(l, "env=")) {
2425                         _cleanup_free_ char *uce = NULL;
2426                         char **e;
2427
2428                         uce = cunescape(l+4);
2429                         if (!uce) {
2430                                 r = -ENOMEM;
2431                                 goto finish;
2432                         }
2433
2434                         e = strv_env_set(m->environment, uce);
2435                         if (!e) {
2436                                 r = -ENOMEM;
2437                                 goto finish;
2438                         }
2439
2440                         strv_free(m->environment);
2441                         m->environment = e;
2442
2443                 } else if (startswith(l, "notify-fd=")) {
2444                         int fd;
2445
2446                         if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2447                                 log_debug("Failed to parse notify fd: %s", l + 10);
2448                         else {
2449                                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2450                                 safe_close(m->notify_fd);
2451                                 m->notify_fd = fdset_remove(fds, fd);
2452                         }
2453
2454                 } else if (startswith(l, "notify-socket=")) {
2455                         char *n;
2456
2457                         n = strdup(l+14);
2458                         if (!n) {
2459                                 r = -ENOMEM;
2460                                 goto finish;
2461                         }
2462
2463                         free(m->notify_socket);
2464                         m->notify_socket = n;
2465
2466                 } else if (startswith(l, "kdbus-fd=")) {
2467                         int fd;
2468
2469                         if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2470                                 log_debug("Failed to parse kdbus fd: %s", l + 9);
2471                         else {
2472                                 safe_close(m->kdbus_fd);
2473                                 m->kdbus_fd = fdset_remove(fds, fd);
2474                         }
2475
2476                 } else {
2477                         int k;
2478
2479                         k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2480                         if (k < 0)
2481                                 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2482                         else if (k == 0)
2483                                 log_debug("Unknown serialization item '%s'", l);
2484                 }
2485         }
2486
2487         for (;;) {
2488                 Unit *u;
2489                 char name[UNIT_NAME_MAX+2];
2490
2491                 /* Start marker */
2492                 if (!fgets(name, sizeof(name), f)) {
2493                         if (feof(f))
2494                                 r = 0;
2495                         else
2496                                 r = -errno;
2497
2498                         goto finish;
2499                 }
2500
2501                 char_array_0(name);
2502
2503                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2504                 if (r < 0)
2505                         goto finish;
2506
2507                 r = unit_deserialize(u, f, fds);
2508                 if (r < 0)
2509                         goto finish;
2510         }
2511
2512 finish:
2513         if (ferror(f))
2514                 r = -EIO;
2515
2516         assert(m->n_reloading > 0);
2517         m->n_reloading --;
2518
2519         return r;
2520 }
2521
2522 int manager_reload(Manager *m) {
2523         int r, q;
2524         _cleanup_fclose_ FILE *f = NULL;
2525         _cleanup_fdset_free_ FDSet *fds = NULL;
2526
2527         assert(m);
2528
2529         r = manager_open_serialization(m, &f);
2530         if (r < 0)
2531                 return r;
2532
2533         m->n_reloading ++;
2534         bus_manager_send_reloading(m, true);
2535
2536         fds = fdset_new();
2537         if (!fds) {
2538                 m->n_reloading --;
2539                 return -ENOMEM;
2540         }
2541
2542         r = manager_serialize(m, f, fds, false);
2543         if (r < 0) {
2544                 m->n_reloading --;
2545                 return r;
2546         }
2547
2548         if (fseeko(f, 0, SEEK_SET) < 0) {
2549                 m->n_reloading --;
2550                 return -errno;
2551         }
2552
2553         /* From here on there is no way back. */
2554         manager_clear_jobs_and_units(m);
2555         manager_undo_generators(m);
2556         lookup_paths_free(&m->lookup_paths);
2557
2558         /* Find new unit paths */
2559         q = manager_run_generators(m);
2560         if (q < 0 && r >= 0)
2561                 r = q;
2562
2563         q = lookup_paths_init(
2564                         &m->lookup_paths, m->running_as, true,
2565                         NULL,
2566                         m->generator_unit_path,
2567                         m->generator_unit_path_early,
2568                         m->generator_unit_path_late);
2569         if (q < 0 && r >= 0)
2570                 r = q;
2571
2572         manager_build_unit_path_cache(m);
2573
2574         /* First, enumerate what we can from all config files */
2575         q = manager_enumerate(m);
2576         if (q < 0 && r >= 0)
2577                 r = q;
2578
2579         /* Second, deserialize our stored data */
2580         q = manager_deserialize(m, f, fds);
2581         if (q < 0 && r >= 0)
2582                 r = q;
2583
2584         fclose(f);
2585         f = NULL;
2586
2587         /* Re-register notify_fd as event source */
2588         q = manager_setup_notify(m);
2589         if (q < 0 && r >= 0)
2590                 r = q;
2591
2592         /* Third, fire things up! */
2593         q = manager_coldplug(m);
2594         if (q < 0 && r >= 0)
2595                 r = q;
2596
2597         assert(m->n_reloading > 0);
2598         m->n_reloading--;
2599
2600         m->send_reloading_done = true;
2601
2602         return r;
2603 }
2604
2605 bool manager_is_reloading_or_reexecuting(Manager *m) {
2606         assert(m);
2607
2608         return m->n_reloading != 0;
2609 }
2610
2611 void manager_reset_failed(Manager *m) {
2612         Unit *u;
2613         Iterator i;
2614
2615         assert(m);
2616
2617         HASHMAP_FOREACH(u, m->units, i)
2618                 unit_reset_failed(u);
2619 }
2620
2621 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2622         Unit *u;
2623
2624         assert(m);
2625         assert(name);
2626
2627         /* Returns true if the unit is inactive or going down */
2628         u = manager_get_unit(m, name);
2629         if (!u)
2630                 return true;
2631
2632         return unit_inactive_or_pending(u);
2633 }
2634
2635 static void manager_notify_finished(Manager *m) {
2636         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2637         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2638
2639         if (m->test_run)
2640                 return;
2641
2642         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2643
2644                 /* Note that m->kernel_usec.monotonic is always at 0,
2645                  * and m->firmware_usec.monotonic and
2646                  * m->loader_usec.monotonic should be considered
2647                  * negative values. */
2648
2649                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2650                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2651                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2652                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2653
2654                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2655
2656                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2657                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2658
2659                         log_struct(LOG_INFO,
2660                                    LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2661                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2662                                    "INITRD_USEC="USEC_FMT, initrd_usec,
2663                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2664                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2665                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2666                                                format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2667                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2668                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2669                                    NULL);
2670                 } else {
2671                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2672                         initrd_usec = 0;
2673
2674                         log_struct(LOG_INFO,
2675                                    LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2676                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2677                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2678                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2679                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2680                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2681                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2682                                    NULL);
2683                 }
2684         } else {
2685                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2686                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2687
2688                 log_struct(LOG_INFO,
2689                            LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2690                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2691                            LOG_MESSAGE("Startup finished in %s.",
2692                                        format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2693                            NULL);
2694         }
2695
2696         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2697
2698         sd_notifyf(false,
2699                    "READY=1\n"
2700                    "STATUS=Startup finished in %s.",
2701                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2702 }
2703
2704 void manager_check_finished(Manager *m) {
2705         Unit *u = NULL;
2706         Iterator i;
2707
2708         assert(m);
2709
2710         if (hashmap_size(m->jobs) > 0) {
2711
2712                 if (m->jobs_in_progress_event_source)
2713                         /* Ignore any failure, this is only for feedback */
2714                         (void) sd_event_source_set_time(m->jobs_in_progress_event_source,
2715                                                         now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2716
2717                 return;
2718         }
2719
2720         manager_flip_auto_status(m, false);
2721
2722         /* Notify Type=idle units that we are done now */
2723         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2724         manager_close_idle_pipe(m);
2725
2726         /* Turn off confirm spawn now */
2727         m->confirm_spawn = false;
2728
2729         /* No need to update ask password status when we're going non-interactive */
2730         manager_close_ask_password(m);
2731
2732         /* This is no longer the first boot */
2733         manager_set_first_boot(m, false);
2734
2735         if (dual_timestamp_is_set(&m->finish_timestamp))
2736                 return;
2737
2738         dual_timestamp_get(&m->finish_timestamp);
2739
2740         manager_notify_finished(m);
2741
2742         SET_FOREACH(u, m->startup_units, i)
2743                 if (u->cgroup_path)
2744                         cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2745 }
2746
2747 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2748         char *p;
2749         int r;
2750
2751         assert(m);
2752         assert(generator);
2753         assert(name);
2754
2755         if (*generator)
2756                 return 0;
2757
2758         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2759                 /* systemd --system, not running --test */
2760
2761                 p = strappend("/run/systemd/", name);
2762                 if (!p)
2763                         return log_oom();
2764
2765                 r = mkdir_p_label(p, 0755);
2766                 if (r < 0) {
2767                         log_error_errno(r, "Failed to create generator directory %s: %m", p);
2768                         free(p);
2769                         return r;
2770                 }
2771         } else if (m->running_as == SYSTEMD_USER) {
2772                 const char *s = NULL;
2773
2774                 s = getenv("XDG_RUNTIME_DIR");
2775                 if (!s)
2776                         return -EINVAL;
2777                 p = strjoin(s, "/systemd/", name, NULL);
2778                 if (!p)
2779                         return log_oom();
2780
2781                 r = mkdir_p_label(p, 0755);
2782                 if (r < 0) {
2783                         log_error_errno(r, "Failed to create generator directory %s: %m", p);
2784                         free(p);
2785                         return r;
2786                 }
2787         } else {
2788                 /* systemd --system --test */
2789
2790                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2791                 if (!p)
2792                         return log_oom();
2793
2794                 if (!mkdtemp(p)) {
2795                         log_error_errno(errno, "Failed to create generator directory %s: %m",
2796                                   p);
2797                         free(p);
2798                         return -errno;
2799                 }
2800         }
2801
2802         *generator = p;
2803         return 0;
2804 }
2805
2806 static void trim_generator_dir(Manager *m, char **generator) {
2807         assert(m);
2808         assert(generator);
2809
2810         if (!*generator)
2811                 return;
2812
2813         if (rmdir(*generator) >= 0) {
2814                 free(*generator);
2815                 *generator = NULL;
2816         }
2817
2818         return;
2819 }
2820
2821 static int manager_run_generators(Manager *m) {
2822         _cleanup_free_ char **paths = NULL;
2823         const char *argv[5];
2824         char **path;
2825         int r;
2826
2827         assert(m);
2828
2829         if (m->test_run)
2830                 return 0;
2831
2832         paths = generator_paths(m->running_as);
2833         if (!paths)
2834                 return log_oom();
2835
2836         /* Optimize by skipping the whole process by not creating output directories
2837          * if no generators are found. */
2838         STRV_FOREACH(path, paths) {
2839                 r = access(*path, F_OK);
2840                 if (r == 0)
2841                         goto found;
2842                 if (errno != ENOENT)
2843                         log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
2844         }
2845         return 0;
2846
2847  found:
2848         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2849         if (r < 0)
2850                 goto finish;
2851
2852         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2853         if (r < 0)
2854                 goto finish;
2855
2856         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2857         if (r < 0)
2858                 goto finish;
2859
2860         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2861         argv[1] = m->generator_unit_path;
2862         argv[2] = m->generator_unit_path_early;
2863         argv[3] = m->generator_unit_path_late;
2864         argv[4] = NULL;
2865
2866         RUN_WITH_UMASK(0022)
2867                 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
2868
2869 finish:
2870         trim_generator_dir(m, &m->generator_unit_path);
2871         trim_generator_dir(m, &m->generator_unit_path_early);
2872         trim_generator_dir(m, &m->generator_unit_path_late);
2873         return r;
2874 }
2875
2876 static void remove_generator_dir(Manager *m, char **generator) {
2877         assert(m);
2878         assert(generator);
2879
2880         if (!*generator)
2881                 return;
2882
2883         strv_remove(m->lookup_paths.unit_path, *generator);
2884         rm_rf(*generator, false, true, false);
2885
2886         free(*generator);
2887         *generator = NULL;
2888 }
2889
2890 static void manager_undo_generators(Manager *m) {
2891         assert(m);
2892
2893         remove_generator_dir(m, &m->generator_unit_path);
2894         remove_generator_dir(m, &m->generator_unit_path_early);
2895         remove_generator_dir(m, &m->generator_unit_path_late);
2896 }
2897
2898 int manager_environment_add(Manager *m, char **minus, char **plus) {
2899         char **a = NULL, **b = NULL, **l;
2900         assert(m);
2901
2902         l = m->environment;
2903
2904         if (!strv_isempty(minus)) {
2905                 a = strv_env_delete(l, 1, minus);
2906                 if (!a)
2907                         return -ENOMEM;
2908
2909                 l = a;
2910         }
2911
2912         if (!strv_isempty(plus)) {
2913                 b = strv_env_merge(2, l, plus);
2914                 if (!b) {
2915                         strv_free(a);
2916                         return -ENOMEM;
2917                 }
2918
2919                 l = b;
2920         }
2921
2922         if (m->environment != l)
2923                 strv_free(m->environment);
2924         if (a != l)
2925                 strv_free(a);
2926         if (b != l)
2927                 strv_free(b);
2928
2929         m->environment = l;
2930         manager_clean_environment(m);
2931         strv_sort(m->environment);
2932
2933         return 0;
2934 }
2935
2936 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2937         int i;
2938
2939         assert(m);
2940
2941         for (i = 0; i < _RLIMIT_MAX; i++) {
2942                 if (!default_rlimit[i])
2943                         continue;
2944
2945                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2946                 if (!m->rlimit[i])
2947                         return -ENOMEM;
2948         }
2949
2950         return 0;
2951 }
2952
2953 void manager_recheck_journal(Manager *m) {
2954         Unit *u;
2955
2956         assert(m);
2957
2958         if (m->running_as != SYSTEMD_SYSTEM)
2959                 return;
2960
2961         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2962         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2963                 log_close_journal();
2964                 return;
2965         }
2966
2967         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2968         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2969                 log_close_journal();
2970                 return;
2971         }
2972
2973         /* Hmm, OK, so the socket is fully up and the service is up
2974          * too, then let's make use of the thing. */
2975         log_open();
2976 }
2977
2978 void manager_set_show_status(Manager *m, ShowStatus mode) {
2979         assert(m);
2980         assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2981
2982         if (m->running_as != SYSTEMD_SYSTEM)
2983                 return;
2984
2985         m->show_status = mode;
2986
2987         if (mode > 0)
2988                 touch("/run/systemd/show-status");
2989         else
2990                 unlink("/run/systemd/show-status");
2991 }
2992
2993 static bool manager_get_show_status(Manager *m, StatusType type) {
2994         assert(m);
2995
2996         if (m->running_as != SYSTEMD_SYSTEM)
2997                 return false;
2998
2999         if (m->no_console_output)
3000                 return false;
3001
3002         if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
3003                 return false;
3004
3005         /* If we cannot find out the status properly, just proceed. */
3006         if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
3007                 return false;
3008
3009         if (m->show_status > 0)
3010                 return true;
3011
3012         /* If Plymouth is running make sure we show the status, so
3013          * that there's something nice to see when people press Esc */
3014         return plymouth_running();
3015 }
3016
3017 void manager_set_first_boot(Manager *m, bool b) {
3018         assert(m);
3019
3020         if (m->running_as != SYSTEMD_SYSTEM)
3021                 return;
3022
3023         m->first_boot = b;
3024
3025         if (m->first_boot)
3026                 touch("/run/systemd/first-boot");
3027         else
3028                 unlink("/run/systemd/first-boot");
3029 }
3030
3031 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
3032         va_list ap;
3033
3034         /* If m is NULL, assume we're after shutdown and let the messages through. */
3035
3036         if (m && !manager_get_show_status(m, type))
3037                 return;
3038
3039         /* XXX We should totally drop the check for ephemeral here
3040          * and thus effectively make 'Type=idle' pointless. */
3041         if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3042                 return;
3043
3044         va_start(ap, format);
3045         status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3046         va_end(ap);
3047 }
3048
3049 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
3050         _cleanup_free_ char *p = NULL;
3051         Unit *found;
3052
3053         assert(m);
3054         assert(path);
3055         assert(suffix);
3056         assert(_found);
3057
3058         p = unit_name_from_path(path, suffix);
3059         if (!p)
3060                 return -ENOMEM;
3061
3062         found = manager_get_unit(m, p);
3063         if (!found) {
3064                 *_found = NULL;
3065                 return 0;
3066         }
3067
3068         *_found = found;
3069         return 1;
3070 }
3071
3072 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3073         char p[strlen(path)+1];
3074
3075         assert(m);
3076         assert(path);
3077
3078         strcpy(p, path);
3079         path_kill_slashes(p);
3080
3081         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3082 }
3083
3084 const char *manager_get_runtime_prefix(Manager *m) {
3085         assert(m);
3086
3087         return m->running_as == SYSTEMD_SYSTEM ?
3088                "/run" :
3089                getenv("XDG_RUNTIME_DIR");
3090 }
3091
3092 void manager_update_failed_units(Manager *m, Unit *u, bool failed) {
3093         unsigned size;
3094
3095         assert(m);
3096         assert(u->manager == m);
3097
3098         size = set_size(m->failed_units);
3099
3100         if (failed) {
3101                 if (set_put(m->failed_units, u) < 0)
3102                         log_oom();
3103         } else
3104                 set_remove(m->failed_units, u);
3105
3106         if (set_size(m->failed_units) != size)
3107                 bus_manager_send_change_signal(m);
3108 }
3109
3110 ManagerState manager_state(Manager *m) {
3111         Unit *u;
3112
3113         assert(m);
3114
3115         /* Did we ever finish booting? If not then we are still starting up */
3116         if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3117
3118                 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3119                 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3120                         return MANAGER_INITIALIZING;
3121
3122                 return MANAGER_STARTING;
3123         }
3124
3125         /* Is the special shutdown target queued? If so, we are in shutdown state */
3126         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3127         if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3128                 return MANAGER_STOPPING;
3129
3130         /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3131         u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3132         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3133                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3134                 return MANAGER_MAINTENANCE;
3135
3136         u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3137         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3138                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3139                 return MANAGER_MAINTENANCE;
3140
3141         /* Are there any failed units? If so, we are in degraded mode */
3142         if (set_size(m->failed_units) > 0)
3143                 return MANAGER_DEGRADED;
3144
3145         return MANAGER_RUNNING;
3146 }
3147
3148 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3149         [MANAGER_INITIALIZING] = "initializing",
3150         [MANAGER_STARTING] = "starting",
3151         [MANAGER_RUNNING] = "running",
3152         [MANAGER_DEGRADED] = "degraded",
3153         [MANAGER_MAINTENANCE] = "maintenance",
3154         [MANAGER_STOPPING] = "stopping",
3155 };
3156
3157 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);