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