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