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