src/core/manager.c

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