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