manager.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU 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 <libcgroup.h>
  35
  36 #include "manager.h"
  37 #include "hashmap.h"
  38 #include "macro.h"
  39 #include "strv.h"
  40 #include "log.h"
  41 #include "util.h"
  42 #include "ratelimit.h"
  43 #include "cgroup.h"
  44 #include "mount-setup.h"
  45
  46 static int manager_setup_signals(Manager *m) {
  47         sigset_t mask;
  48         struct epoll_event ev;
  49
  50         assert(m);
  51
  52         assert_se(reset_all_signal_handlers() == 0);
  53
  54         assert_se(sigemptyset(&mask) == 0);
  55         assert_se(sigaddset(&mask, SIGCHLD) == 0);
  56         assert_se(sigaddset(&mask, SIGINT) == 0);   /* Kernel sends us this on control-alt-del */
  57         assert_se(sigaddset(&mask, SIGWINCH) == 0); /* Kernel sends us this on kbrequest (alt-arrowup) */
  58         assert_se(sigaddset(&mask, SIGTERM) == 0);
  59         assert_se(sigaddset(&mask, SIGHUP) == 0);
  60         assert_se(sigaddset(&mask, SIGUSR1) == 0);
  61         assert_se(sigaddset(&mask, SIGUSR2) == 0);
  62         assert_se(sigaddset(&mask, SIGPIPE) == 0);
  63         assert_se(sigaddset(&mask, SIGPWR) == 0);
  64         assert_se(sigaddset(&mask, SIGTTIN) == 0);
  65         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
  66
  67         m->signal_watch.type = WATCH_SIGNAL;
  68         if ((m->signal_watch.fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC)) < 0)
  69                 return -errno;
  70
  71         zero(ev);
  72         ev.events = EPOLLIN;
  73         ev.data.ptr = &m->signal_watch;
  74
  75         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->signal_watch.fd, &ev) < 0)
  76                 return -errno;
  77
  78         if (m->running_as == MANAGER_INIT) {
  79                 /* Enable that we get SIGINT on control-alt-del */
  80                 if (reboot(RB_DISABLE_CAD) < 0)
  81                         log_warning("Failed to enable ctrl-alt-del handling: %s", strerror(errno));
  82
  83                 /* Enable that we get SIGWINCH on kbrequest */
  84                 if (ioctl(0, KDSIGACCEPT, SIGWINCH) < 0)
  85                         log_warning("Failed to enable kbrequest handling: %s", strerror(errno));
  86         }
  87
  88         return 0;
  89 }
  90
  91 static char** session_dirs(void) {
  92         const char *home, *e;
  93         char *config_home = NULL, *data_home = NULL;
  94         char **config_dirs = NULL, **data_dirs = NULL;
  95         char **r = NULL, **t;
  96
  97         /* Implement the mechanisms defined in
  98          *
  99          * http://standards.freedesktop.org/basedir-spec/basedir-spec-0.6.html
 100          *
 101          * We look in both the config and the data dirs because we
 102          * want to encourage that distributors ship their unit files
 103          * as data, and allow overriding as configuration.
 104          */
 105
 106         home = getenv("HOME");
 107
 108         if ((e = getenv("XDG_CONFIG_HOME"))) {
 109                 if (asprintf(&config_home, "%s/systemd/session", e) < 0)
 110                         goto fail;
 111
 112         } else if (home) {
 113                 if (asprintf(&config_home, "%s/.config/systemd/session", home) < 0)
 114                         goto fail;
 115         }
 116
 117         if ((e = getenv("XDG_CONFIG_DIRS")))
 118                 config_dirs = strv_split(e, ":");
 119         else
 120                 config_dirs = strv_new("/etc/xdg", NULL);
 121
 122         if (!config_dirs)
 123                 goto fail;
 124
 125         if ((e = getenv("XDG_DATA_HOME"))) {
 126                 if (asprintf(&data_home, "%s/systemd/session", e) < 0)
 127                         goto fail;
 128
 129         } else if (home) {
 130                 if (asprintf(&data_home, "%s/.local/share/systemd/session", home) < 0)
 131                         goto fail;
 132         }
 133
 134         if ((e = getenv("XDG_DATA_DIRS")))
 135                 data_dirs = strv_split(e, ":");
 136         else
 137                 data_dirs = strv_new("/usr/local/share", "/usr/share", NULL);
 138
 139         if (!data_dirs)
 140                 goto fail;
 141
 142         /* Now merge everything we found. */
 143         if (config_home) {
 144                 if (!(t = strv_append(r, config_home)))
 145                         goto fail;
 146                 strv_free(r);
 147                 r = t;
 148         }
 149
 150         if (!(t = strv_merge_concat(r, config_dirs, "/systemd/session")))
 151                 goto finish;
 152         strv_free(r);
 153         r = t;
 154
 155         if (!(t = strv_append(r, SESSION_CONFIG_UNIT_PATH)))
 156                 goto fail;
 157         strv_free(r);
 158         r = t;
 159
 160         if (data_home) {
 161                 if (!(t = strv_append(r, data_home)))
 162                         goto fail;
 163                 strv_free(r);
 164                 r = t;
 165         }
 166
 167         if (!(t = strv_merge_concat(r, data_dirs, "/systemd/session")))
 168                 goto fail;
 169         strv_free(r);
 170         r = t;
 171
 172         if (!(t = strv_append(r, SESSION_DATA_UNIT_PATH)))
 173                 goto fail;
 174         strv_free(r);
 175         r = t;
 176
 177         if (!strv_path_make_absolute_cwd(r))
 178             goto fail;
 179
 180 finish:
 181         free(config_home);
 182         strv_free(config_dirs);
 183         free(data_home);
 184         strv_free(data_dirs);
 185
 186         return r;
 187
 188 fail:
 189         strv_free(r);
 190         r = NULL;
 191         goto finish;
 192 }
 193
 194 static int manager_find_paths(Manager *m) {
 195         const char *e;
 196         char *t;
 197         assert(m);
 198
 199         /* First priority is whatever has been passed to us via env
 200          * vars */
 201         if ((e = getenv("SYSTEMD_UNIT_PATH")))
 202                 if (!(m->unit_path = split_path_and_make_absolute(e)))
 203                         return -ENOMEM;
 204
 205         if (strv_isempty(m->unit_path)) {
 206
 207                 /* Nothing is set, so let's figure something out. */
 208                 strv_free(m->unit_path);
 209
 210                 if (m->running_as == MANAGER_SESSION) {
 211                         if (!(m->unit_path = session_dirs()))
 212                                 return -ENOMEM;
 213                 } else
 214                         if (!(m->unit_path = strv_new(
 215                                               SYSTEM_CONFIG_UNIT_PATH,  /* /etc/systemd/system/ */
 216                                               SYSTEM_DATA_UNIT_PATH,    /* /lib/systemd/system/ */
 217                                               NULL)))
 218                                 return -ENOMEM;
 219         }
 220
 221         if (m->running_as == MANAGER_INIT) {
 222                 /* /etc/init.d/ compativility does not matter to users */
 223
 224                 if ((e = getenv("SYSTEMD_SYSVINIT_PATH")))
 225                         if (!(m->sysvinit_path = split_path_and_make_absolute(e)))
 226                                 return -ENOMEM;
 227
 228                 if (strv_isempty(m->sysvinit_path)) {
 229                         strv_free(m->sysvinit_path);
 230
 231                         if (!(m->sysvinit_path = strv_new(
 232                                               SYSTEM_SYSVINIT_PATH,     /* /etc/init.d/ */
 233                                               NULL)))
 234                                 return -ENOMEM;
 235                 }
 236         }
 237
 238         strv_uniq(m->unit_path);
 239         strv_uniq(m->sysvinit_path);
 240
 241         assert(!strv_isempty(m->unit_path));
 242         if (!(t = strv_join(m->unit_path, "\n\t")))
 243                 return -ENOMEM;
 244         log_debug("Looking for unit files in:\n\t%s", t);
 245         free(t);
 246
 247         if (!strv_isempty(m->sysvinit_path)) {
 248
 249                 if (!(t = strv_join(m->sysvinit_path, "\n\t")))
 250                         return -ENOMEM;
 251
 252                 log_debug("Looking for SysV init scripts in:\n\t%s", t);
 253                 free(t);
 254         } else
 255                 log_debug("Ignoring SysV init scripts.");
 256
 257         return 0;
 258 }
 259
 260 int manager_new(Manager **_m) {
 261         Manager *m;
 262         int r = -ENOMEM;
 263
 264         assert(_m);
 265
 266         if (!(m = new0(Manager, 1)))
 267                 return -ENOMEM;
 268
 269         m->signal_watch.fd = m->mount_watch.fd = m->udev_watch.fd = m->epoll_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         if (!(m->units = hashmap_new(string_hash_func, string_compare_func)))
 273                 goto fail;
 274
 275         if (!(m->jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
 276                 goto fail;
 277
 278         if (!(m->transaction_jobs = hashmap_new(trivial_hash_func, trivial_compare_func)))
 279                 goto fail;
 280
 281         if (!(m->watch_pids = hashmap_new(trivial_hash_func, trivial_compare_func)))
 282                 goto fail;
 283
 284         if (!(m->cgroup_bondings = hashmap_new(string_hash_func, string_compare_func)))
 285                 goto fail;
 286
 287         if ((m->epoll_fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
 288                 goto fail;
 289
 290         if (getpid() == 1)
 291                 m->running_as = MANAGER_INIT;
 292         else if (getuid() == 0)
 293                 m->running_as = MANAGER_SYSTEM;
 294         else
 295                 m->running_as = MANAGER_SESSION;
 296
 297         log_debug("systemd running in %s mode.", manager_running_as_to_string(m->running_as));
 298
 299         if ((r = manager_find_paths(m)) < 0)
 300                 goto fail;
 301
 302         if (chdir("/") < 0)
 303                 log_warning("Failed to chdir to /: %s", strerror(errno));
 304
 305         /* Become a session leader if we aren't one yet. */
 306         setsid();
 307
 308         if ((r = manager_setup_signals(m)) < 0)
 309                 goto fail;
 310
 311         if ((r = mount_setup()) < 0)
 312                 goto fail;
 313
 314         if ((r = manager_setup_cgroup(m)) < 0)
 315                 goto fail;
 316
 317         /* FIXME: this should be called only when the D-Bus bus daemon is running */
 318         if ((r = bus_init(m)) < 0)
 319                 goto fail;
 320
 321         *_m = m;
 322         return 0;
 323
 324 fail:
 325         manager_free(m);
 326         return r;
 327 }
 328
 329 void manager_free(Manager *m) {
 330         UnitType c;
 331         Unit *u;
 332         Job *j;
 333
 334         assert(m);
 335
 336         while ((j = hashmap_first(m->transaction_jobs)))
 337                 job_free(j);
 338
 339         while ((u = hashmap_first(m->units)))
 340                 unit_free(u);
 341
 342         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 343                 if (unit_vtable[c]->shutdown)
 344                         unit_vtable[c]->shutdown(m);
 345
 346         manager_shutdown_cgroup(m);
 347
 348         bus_done(m);
 349
 350         hashmap_free(m->units);
 351         hashmap_free(m->jobs);
 352         hashmap_free(m->transaction_jobs);
 353         hashmap_free(m->watch_pids);
 354
 355         if (m->epoll_fd >= 0)
 356                 close_nointr(m->epoll_fd);
 357         if (m->signal_watch.fd >= 0)
 358                 close_nointr(m->signal_watch.fd);
 359
 360         strv_free(m->unit_path);
 361         strv_free(m->sysvinit_path);
 362
 363         free(m->cgroup_controller);
 364         free(m->cgroup_hierarchy);
 365
 366         assert(hashmap_isempty(m->cgroup_bondings));
 367         hashmap_free(m->cgroup_bondings);
 368
 369         free(m);
 370 }
 371
 372 int manager_coldplug(Manager *m) {
 373         int r;
 374         UnitType c;
 375         Iterator i;
 376         Unit *u;
 377         char *k;
 378
 379         assert(m);
 380
 381         /* First, let's ask every type to load all units from
 382          * disk/kernel that it might know */
 383         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 384                 if (unit_vtable[c]->enumerate)
 385                         if ((r = unit_vtable[c]->enumerate(m)) < 0)
 386                                 return r;
 387
 388         manager_dispatch_load_queue(m);
 389
 390         /* Then, let's set up their initial state. */
 391         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 392
 393                 /* ignore aliases */
 394                 if (unit_id(u) != k)
 395                         continue;
 396
 397                 if (UNIT_VTABLE(u)->coldplug)
 398                         if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
 399                                 return r;
 400         }
 401
 402         return 0;
 403 }
 404
 405 static void transaction_delete_job(Manager *m, Job *j) {
 406         assert(m);
 407         assert(j);
 408
 409         /* Deletes one job from the transaction */
 410
 411         manager_transaction_unlink_job(m, j);
 412
 413         if (!j->installed)
 414                 job_free(j);
 415 }
 416
 417 static void transaction_delete_unit(Manager *m, Unit *u) {
 418         Job *j;
 419
 420         /* Deletes all jobs associated with a certain unit from the
 421          * transaction */
 422
 423         while ((j = hashmap_get(m->transaction_jobs, u)))
 424                 transaction_delete_job(m, j);
 425 }
 426
 427 static void transaction_clean_dependencies(Manager *m) {
 428         Iterator i;
 429         Job *j;
 430
 431         assert(m);
 432
 433         /* Drops all dependencies of all installed jobs */
 434
 435         HASHMAP_FOREACH(j, m->jobs, i) {
 436                 while (j->subject_list)
 437                         job_dependency_free(j->subject_list);
 438                 while (j->object_list)
 439                         job_dependency_free(j->object_list);
 440         }
 441
 442         assert(!m->transaction_anchor);
 443 }
 444
 445 static void transaction_abort(Manager *m) {
 446         Job *j;
 447
 448         assert(m);
 449
 450         while ((j = hashmap_first(m->transaction_jobs)))
 451                 if (j->installed)
 452                         transaction_delete_job(m, j);
 453                 else
 454                         job_free(j);
 455
 456         assert(hashmap_isempty(m->transaction_jobs));
 457
 458         transaction_clean_dependencies(m);
 459 }
 460
 461 static void transaction_find_jobs_that_matter_to_anchor(Manager *m, Job *j, unsigned generation) {
 462         JobDependency *l;
 463
 464         assert(m);
 465
 466         /* A recursive sweep through the graph that marks all units
 467          * that matter to the anchor job, i.e. are directly or
 468          * indirectly a dependency of the anchor job via paths that
 469          * are fully marked as mattering. */
 470
 471         if (j)
 472                 l = j->subject_list;
 473         else
 474                 l = m->transaction_anchor;
 475
 476         LIST_FOREACH(subject, l, l) {
 477
 478                 /* This link does not matter */
 479                 if (!l->matters)
 480                         continue;
 481
 482                 /* This unit has already been marked */
 483                 if (l->object->generation == generation)
 484                         continue;
 485
 486                 l->object->matters_to_anchor = true;
 487                 l->object->generation = generation;
 488
 489                 transaction_find_jobs_that_matter_to_anchor(m, l->object, generation);
 490         }
 491 }
 492
 493 static void transaction_merge_and_delete_job(Manager *m, Job *j, Job *other, JobType t) {
 494         JobDependency *l, *last;
 495
 496         assert(j);
 497         assert(other);
 498         assert(j->unit == other->unit);
 499         assert(!j->installed);
 500
 501         /* Merges 'other' into 'j' and then deletes j. */
 502
 503         j->type = t;
 504         j->state = JOB_WAITING;
 505         j->forced = j->forced || other->forced;
 506
 507         j->matters_to_anchor = j->matters_to_anchor || other->matters_to_anchor;
 508
 509         /* Patch us in as new owner of the JobDependency objects */
 510         last = NULL;
 511         LIST_FOREACH(subject, l, other->subject_list) {
 512                 assert(l->subject == other);
 513                 l->subject = j;
 514                 last = l;
 515         }
 516
 517         /* Merge both lists */
 518         if (last) {
 519                 last->subject_next = j->subject_list;
 520                 if (j->subject_list)
 521                         j->subject_list->subject_prev = last;
 522                 j->subject_list = other->subject_list;
 523         }
 524
 525         /* Patch us in as new owner of the JobDependency objects */
 526         last = NULL;
 527         LIST_FOREACH(object, l, other->object_list) {
 528                 assert(l->object == other);
 529                 l->object = j;
 530                 last = l;
 531         }
 532
 533         /* Merge both lists */
 534         if (last) {
 535                 last->object_next = j->object_list;
 536                 if (j->object_list)
 537                         j->object_list->object_prev = last;
 538                 j->object_list = other->object_list;
 539         }
 540
 541         /* Kill the other job */
 542         other->subject_list = NULL;
 543         other->object_list = NULL;
 544         transaction_delete_job(m, other);
 545 }
 546
 547 static int delete_one_unmergeable_job(Manager *m, Job *j) {
 548         Job *k;
 549
 550         assert(j);
 551
 552         /* Tries to delete one item in the linked list
 553          * j->transaction_next->transaction_next->... that conflicts
 554          * whith another one, in an attempt to make an inconsistent
 555          * transaction work. */
 556
 557         /* We rely here on the fact that if a merged with b does not
 558          * merge with c, either a or b merge with c neither */
 559         LIST_FOREACH(transaction, j, j)
 560                 LIST_FOREACH(transaction, k, j->transaction_next) {
 561                         Job *d;
 562
 563                         /* Is this one mergeable? Then skip it */
 564                         if (job_type_is_mergeable(j->type, k->type))
 565                                 continue;
 566
 567                         /* Ok, we found two that conflict, let's see if we can
 568                          * drop one of them */
 569                         if (!j->matters_to_anchor)
 570                                 d = j;
 571                         else if (!k->matters_to_anchor)
 572                                 d = k;
 573                         else
 574                                 return -ENOEXEC;
 575
 576                         /* Ok, we can drop one, so let's do so. */
 577                         log_debug("Try to fix job merging by deleting job %s/%s", unit_id(d->unit), job_type_to_string(d->type));
 578                         transaction_delete_job(m, d);
 579                         return 0;
 580                 }
 581
 582         return -EINVAL;
 583 }
 584
 585 static int transaction_merge_jobs(Manager *m) {
 586         Job *j;
 587         Iterator i;
 588         int r;
 589
 590         assert(m);
 591
 592         /* First step, check whether any of the jobs for one specific
 593          * task conflict. If so, try to drop one of them. */
 594         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 595                 JobType t;
 596                 Job *k;
 597
 598                 t = j->type;
 599                 LIST_FOREACH(transaction, k, j->transaction_next) {
 600                         if ((r = job_type_merge(&t, k->type)) >= 0)
 601                                 continue;
 602
 603                         /* OK, we could not merge all jobs for this
 604                          * action. Let's see if we can get rid of one
 605                          * of them */
 606
 607                         if ((r = delete_one_unmergeable_job(m, j)) >= 0)
 608                                 /* Ok, we managed to drop one, now
 609                                  * let's ask our callers to call us
 610                                  * again after garbage collecting */
 611                                 return -EAGAIN;
 612
 613                         /* We couldn't merge anything. Failure */
 614                         return r;
 615                 }
 616         }
 617
 618         /* Second step, merge the jobs. */
 619         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 620                 JobType t = j->type;
 621                 Job *k;
 622
 623                 /* Merge all transactions */
 624                 LIST_FOREACH(transaction, k, j->transaction_next)
 625                         assert_se(job_type_merge(&t, k->type) == 0);
 626
 627                 /* If an active job is mergeable, merge it too */
 628                 if (j->unit->meta.job)
 629                         job_type_merge(&t, j->unit->meta.job->type); /* Might fail. Which is OK */
 630
 631                 while ((k = j->transaction_next)) {
 632                         if (j->installed) {
 633                                 transaction_merge_and_delete_job(m, k, j, t);
 634                                 j = k;
 635                         } else
 636                                 transaction_merge_and_delete_job(m, j, k, t);
 637                 }
 638
 639                 assert(!j->transaction_next);
 640                 assert(!j->transaction_prev);
 641         }
 642
 643         return 0;
 644 }
 645
 646 static bool unit_matters_to_anchor(Unit *u, Job *j) {
 647         assert(u);
 648         assert(!j->transaction_prev);
 649
 650         /* Checks whether at least one of the jobs for this unit
 651          * matters to the anchor. */
 652
 653         LIST_FOREACH(transaction, j, j)
 654                 if (j->matters_to_anchor)
 655                         return true;
 656
 657         return false;
 658 }
 659
 660 static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned generation) {
 661         Iterator i;
 662         Unit *u;
 663         int r;
 664
 665         assert(m);
 666         assert(j);
 667         assert(!j->transaction_prev);
 668
 669         /* Does a recursive sweep through the ordering graph, looking
 670          * for a cycle. If we find cycle we try to break it. */
 671
 672         /* Did we find a cycle? */
 673         if (j->marker && j->generation == generation) {
 674                 Job *k;
 675
 676                 /* So, we already have been here. We have a
 677                  * cycle. Let's try to break it. We go backwards in
 678                  * our path and try to find a suitable job to
 679                  * remove. We use the marker to find our way back,
 680                  * since smart how we are we stored our way back in
 681                  * there. */
 682
 683                 log_debug("Found cycle on %s/%s", unit_id(j->unit), job_type_to_string(j->type));
 684
 685                 for (k = from; k; k = (k->generation == generation ? k->marker : NULL)) {
 686
 687                         log_debug("Walked on cycle path to %s/%s", unit_id(j->unit), job_type_to_string(j->type));
 688
 689                         if (!k->installed &&
 690                             !unit_matters_to_anchor(k->unit, k)) {
 691                                 /* Ok, we can drop this one, so let's
 692                                  * do so. */
 693                                 log_debug("Breaking order cycle by deleting job %s/%s", unit_id(k->unit), job_type_to_string(k->type));
 694                                 transaction_delete_unit(m, k->unit);
 695                                 return -EAGAIN;
 696                         }
 697
 698                         /* Check if this in fact was the beginning of
 699                          * the cycle */
 700                         if (k == j)
 701                                 break;
 702                 }
 703
 704                 log_debug("Unable to break cycle");
 705
 706                 return -ENOEXEC;
 707         }
 708
 709         /* Make the marker point to where we come from, so that we can
 710          * find our way backwards if we want to break a cycle */
 711         j->marker = from;
 712         j->generation = generation;
 713
 714         /* We assume that the the dependencies are bidirectional, and
 715          * hence can ignore UNIT_AFTER */
 716         SET_FOREACH(u, j->unit->meta.dependencies[UNIT_BEFORE], i) {
 717                 Job *o;
 718
 719                 /* Is there a job for this unit? */
 720                 if (!(o = hashmap_get(m->transaction_jobs, u)))
 721
 722                         /* Ok, there is no job for this in the
 723                          * transaction, but maybe there is already one
 724                          * running? */
 725                         if (!(o = u->meta.job))
 726                                 continue;
 727
 728                 if ((r = transaction_verify_order_one(m, o, j, generation)) < 0)
 729                         return r;
 730         }
 731
 732         /* Ok, let's backtrack, and remember that this entry is not on
 733          * our path anymore. */
 734         j->marker = NULL;
 735
 736         return 0;
 737 }
 738
 739 static int transaction_verify_order(Manager *m, unsigned *generation) {
 740         Job *j;
 741         int r;
 742         Iterator i;
 743
 744         assert(m);
 745         assert(generation);
 746
 747         /* Check if the ordering graph is cyclic. If it is, try to fix
 748          * that up by dropping one of the jobs. */
 749
 750         HASHMAP_FOREACH(j, m->transaction_jobs, i)
 751                 if ((r = transaction_verify_order_one(m, j, NULL, (*generation)++)) < 0)
 752                         return r;
 753
 754         return 0;
 755 }
 756
 757 static void transaction_collect_garbage(Manager *m) {
 758         bool again;
 759
 760         assert(m);
 761
 762         /* Drop jobs that are not required by any other job */
 763
 764         do {
 765                 Iterator i;
 766                 Job *j;
 767
 768                 again = false;
 769
 770                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 771                         if (j->object_list)
 772                                 continue;
 773
 774                         log_debug("Garbage collecting job %s/%s", unit_id(j->unit), job_type_to_string(j->type));
 775                         transaction_delete_job(m, j);
 776                         again = true;
 777                         break;
 778                 }
 779
 780         } while (again);
 781 }
 782
 783 static int transaction_is_destructive(Manager *m, JobMode mode) {
 784         Iterator i;
 785         Job *j;
 786
 787         assert(m);
 788
 789         /* Checks whether applying this transaction means that
 790          * existing jobs would be replaced */
 791
 792         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 793
 794                 /* Assume merged */
 795                 assert(!j->transaction_prev);
 796                 assert(!j->transaction_next);
 797
 798                 if (j->unit->meta.job &&
 799                     j->unit->meta.job != j &&
 800                     !job_type_is_superset(j->type, j->unit->meta.job->type))
 801                         return -EEXIST;
 802         }
 803
 804         return 0;
 805 }
 806
 807 static void transaction_minimize_impact(Manager *m) {
 808         bool again;
 809         assert(m);
 810
 811         /* Drops all unnecessary jobs that reverse already active jobs
 812          * or that stop a running service. */
 813
 814         do {
 815                 Job *j;
 816                 Iterator i;
 817
 818                 again = false;
 819
 820                 HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 821                         LIST_FOREACH(transaction, j, j) {
 822                                 bool stops_running_service, changes_existing_job;
 823
 824                                 /* If it matters, we shouldn't drop it */
 825                                 if (j->matters_to_anchor)
 826                                         continue;
 827
 828                                 /* Would this stop a running service?
 829                                  * Would this change an existing job?
 830                                  * If so, let's drop this entry */
 831
 832                                 stops_running_service =
 833                                         j->type == JOB_STOP && UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(j->unit));
 834
 835                                 changes_existing_job =
 836                                         j->unit->meta.job && job_type_is_conflicting(j->type, j->unit->meta.job->state);
 837
 838                                 if (!stops_running_service && !changes_existing_job)
 839                                         continue;
 840
 841                                 if (stops_running_service)
 842                                         log_debug("%s/%s would stop a running service.", unit_id(j->unit), job_type_to_string(j->type));
 843
 844                                 if (changes_existing_job)
 845                                         log_debug("%s/%s would change existing job.", unit_id(j->unit), job_type_to_string(j->type));
 846
 847                                 /* Ok, let's get rid of this */
 848                                 log_debug("Deleting %s/%s to minimize impact.", unit_id(j->unit), job_type_to_string(j->type));
 849
 850                                 transaction_delete_job(m, j);
 851                                 again = true;
 852                                 break;
 853                         }
 854
 855                         if (again)
 856                                 break;
 857                 }
 858
 859         } while (again);
 860 }
 861
 862 static int transaction_apply(Manager *m, JobMode mode) {
 863         Iterator i;
 864         Job *j;
 865         int r;
 866
 867         /* Moves the transaction jobs to the set of active jobs */
 868
 869         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 870                 /* Assume merged */
 871                 assert(!j->transaction_prev);
 872                 assert(!j->transaction_next);
 873
 874                 if (j->installed)
 875                         continue;
 876
 877                 if ((r = hashmap_put(m->jobs, UINT32_TO_PTR(j->id), j)) < 0)
 878                         goto rollback;
 879         }
 880
 881         while ((j = hashmap_steal_first(m->transaction_jobs))) {
 882                 if (j->installed)
 883                         continue;
 884
 885                 if (j->unit->meta.job)
 886                         job_free(j->unit->meta.job);
 887
 888                 j->unit->meta.job = j;
 889                 j->installed = true;
 890
 891                 /* We're fully installed. Now let's free data we don't
 892                  * need anymore. */
 893
 894                 assert(!j->transaction_next);
 895                 assert(!j->transaction_prev);
 896
 897                 job_add_to_run_queue(j);
 898                 job_add_to_dbus_queue(j);
 899         }
 900
 901         /* As last step, kill all remaining job dependencies. */
 902         transaction_clean_dependencies(m);
 903
 904         return 0;
 905
 906 rollback:
 907
 908         HASHMAP_FOREACH(j, m->transaction_jobs, i) {
 909                 if (j->installed)
 910                         continue;
 911
 912                 hashmap_remove(m->jobs, UINT32_TO_PTR(j->id));
 913         }
 914
 915         return r;
 916 }
 917
 918 static int transaction_activate(Manager *m, JobMode mode) {
 919         int r;
 920         unsigned generation = 1;
 921
 922         assert(m);
 923
 924         /* This applies the changes recorded in transaction_jobs to
 925          * the actual list of jobs, if possible. */
 926
 927         /* First step: figure out which jobs matter */
 928         transaction_find_jobs_that_matter_to_anchor(m, NULL, generation++);
 929
 930         /* Second step: Try not to stop any running services if
 931          * we don't have to. Don't try to reverse running
 932          * jobs if we don't have to. */
 933         transaction_minimize_impact(m);
 934
 935         for (;;) {
 936                 /* Third step: Let's remove unneeded jobs that might
 937                  * be lurking. */
 938                 transaction_collect_garbage(m);
 939
 940                 /* Fourth step: verify order makes sense and correct
 941                  * cycles if necessary and possible */
 942                 if ((r = transaction_verify_order(m, &generation)) >= 0)
 943                         break;
 944
 945                 if (r != -EAGAIN) {
 946                         log_debug("Requested transaction contains an unfixable cyclic ordering dependency: %s", strerror(-r));
 947                         goto rollback;
 948                 }
 949
 950                 /* Let's see if the resulting transaction ordering
 951                  * graph is still cyclic... */
 952         }
 953
 954         for (;;) {
 955                 /* Fifth step: let's drop unmergeable entries if
 956                  * necessary and possible, merge entries we can
 957                  * merge */
 958                 if ((r = transaction_merge_jobs(m)) >= 0)
 959                         break;
 960
 961                 if (r != -EAGAIN) {
 962                         log_debug("Requested transaction contains unmergable jobs: %s", strerror(-r));
 963                         goto rollback;
 964                 }
 965
 966                 /* Sixth step: an entry got dropped, let's garbage
 967                  * collect its dependencies. */
 968                 transaction_collect_garbage(m);
 969
 970                 /* Let's see if the resulting transaction still has
 971                  * unmergeable entries ... */
 972         }
 973
 974         /* Seventh step: check whether we can actually apply this */
 975         if (mode == JOB_FAIL)
 976                 if ((r = transaction_is_destructive(m, mode)) < 0) {
 977                         log_debug("Requested transaction contradicts existing jobs: %s", strerror(-r));
 978                         goto rollback;
 979                 }
 980
 981         /* Eights step: apply changes */
 982         if ((r = transaction_apply(m, mode)) < 0) {
 983                 log_debug("Failed to apply transaction: %s", strerror(-r));
 984                 goto rollback;
 985         }
 986
 987         assert(hashmap_isempty(m->transaction_jobs));
 988         assert(!m->transaction_anchor);
 989
 990         return 0;
 991
 992 rollback:
 993         transaction_abort(m);
 994         return r;
 995 }
 996
 997 static Job* transaction_add_one_job(Manager *m, JobType type, Unit *unit, bool force, bool *is_new) {
 998         Job *j, *f;
 999         int r;
1000
1001         assert(m);
1002         assert(unit);
1003
1004         /* Looks for an axisting prospective job and returns that. If
1005          * it doesn't exist it is created and added to the prospective
1006          * jobs list. */
1007
1008         f = hashmap_get(m->transaction_jobs, unit);
1009
1010         LIST_FOREACH(transaction, j, f) {
1011                 assert(j->unit == unit);
1012
1013                 if (j->type == type) {
1014                         if (is_new)
1015                                 *is_new = false;
1016                         return j;
1017                 }
1018         }
1019
1020         if (unit->meta.job && unit->meta.job->type == type)
1021                 j = unit->meta.job;
1022         else if (!(j = job_new(m, type, unit)))
1023                 return NULL;
1024
1025         j->generation = 0;
1026         j->marker = NULL;
1027         j->matters_to_anchor = false;
1028         j->forced = force;
1029
1030         LIST_PREPEND(Job, transaction, f, j);
1031
1032         if ((r = hashmap_replace(m->transaction_jobs, unit, f)) < 0) {
1033                 job_free(j);
1034                 return NULL;
1035         }
1036
1037         if (is_new)
1038                 *is_new = true;
1039
1040         return j;
1041 }
1042
1043 void manager_transaction_unlink_job(Manager *m, Job *j) {
1044         assert(m);
1045         assert(j);
1046
1047         if (j->transaction_prev)
1048                 j->transaction_prev->transaction_next = j->transaction_next;
1049         else if (j->transaction_next)
1050                 hashmap_replace(m->transaction_jobs, j->unit, j->transaction_next);
1051         else
1052                 hashmap_remove_value(m->transaction_jobs, j->unit, j);
1053
1054         if (j->transaction_next)
1055                 j->transaction_next->transaction_prev = j->transaction_prev;
1056
1057         j->transaction_prev = j->transaction_next = NULL;
1058
1059         while (j->subject_list)
1060                 job_dependency_free(j->subject_list);
1061
1062         while (j->object_list) {
1063                 Job *other = j->object_list->matters ? j->object_list->subject : NULL;
1064
1065                 job_dependency_free(j->object_list);
1066
1067                 if (other) {
1068                         log_debug("Deleting job %s/%s as dependency of job %s/%s",
1069                                   unit_id(other->unit), job_type_to_string(other->type),
1070                                   unit_id(j->unit), job_type_to_string(j->type));
1071                         transaction_delete_job(m, other);
1072                 }
1073         }
1074 }
1075
1076 static int transaction_add_job_and_dependencies(Manager *m, JobType type, Unit *unit, Job *by, bool matters, bool force, Job **_ret) {
1077         Job *ret;
1078         Iterator i;
1079         Unit *dep;
1080         int r;
1081         bool is_new;
1082
1083         assert(m);
1084         assert(type < _JOB_TYPE_MAX);
1085         assert(unit);
1086
1087         if (unit->meta.load_state != UNIT_LOADED)
1088                 return -EINVAL;
1089
1090         if (!unit_job_is_applicable(unit, type))
1091                 return -EBADR;
1092
1093         /* First add the job. */
1094         if (!(ret = transaction_add_one_job(m, type, unit, force, &is_new)))
1095                 return -ENOMEM;
1096
1097         /* Then, add a link to the job. */
1098         if (!job_dependency_new(by, ret, matters))
1099                 return -ENOMEM;
1100
1101         if (is_new) {
1102                 /* Finally, recursively add in all dependencies. */
1103                 if (type == JOB_START || type == JOB_RELOAD_OR_START) {
1104                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRES], i)
1105                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
1106                                         goto fail;
1107                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_SOFT_REQUIRES], i)
1108                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, !force, force, NULL)) < 0 && r != -EBADR)
1109                                         goto fail;
1110                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_WANTS], i)
1111                                 if ((r = transaction_add_job_and_dependencies(m, JOB_START, dep, ret, false, force, NULL)) < 0 && r != -EBADR)
1112                                         goto fail;
1113                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUISITE], i)
1114                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
1115                                         goto fail;
1116                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_SOFT_REQUISITE], i)
1117                                 if ((r = transaction_add_job_and_dependencies(m, JOB_VERIFY_ACTIVE, dep, ret, !force, force, NULL)) < 0 && r != -EBADR)
1118                                         goto fail;
1119                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_CONFLICTS], i)
1120                                 if ((r = transaction_add_job_and_dependencies(m, JOB_STOP, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
1121                                         goto fail;
1122
1123                 } else if (type == JOB_STOP || type == JOB_RESTART || type == JOB_TRY_RESTART) {
1124
1125                         SET_FOREACH(dep, ret->unit->meta.dependencies[UNIT_REQUIRED_BY], i)
1126                                 if ((r = transaction_add_job_and_dependencies(m, type, dep, ret, true, force, NULL)) < 0 && r != -EBADR)
1127                                         goto fail;
1128                 }
1129
1130                 /* JOB_VERIFY_STARTED, JOB_RELOAD require no dependency handling */
1131         }
1132
1133         if (_ret)
1134                 *_ret = ret;
1135
1136         return 0;
1137
1138 fail:
1139         return r;
1140 }
1141
1142 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool force, Job **_ret) {
1143         int r;
1144         Job *ret;
1145
1146         assert(m);
1147         assert(type < _JOB_TYPE_MAX);
1148         assert(unit);
1149         assert(mode < _JOB_MODE_MAX);
1150
1151         log_debug("Trying to enqueue job %s/%s", unit_id(unit), job_type_to_string(type));
1152
1153         if ((r = transaction_add_job_and_dependencies(m, type, unit, NULL, true, force, &ret)) < 0) {
1154                 transaction_abort(m);
1155                 return r;
1156         }
1157
1158         if ((r = transaction_activate(m, mode)) < 0)
1159                 return r;
1160
1161         log_debug("Enqueued job %s/%s as %u", unit_id(unit), job_type_to_string(type), (unsigned) ret->id);
1162
1163         if (_ret)
1164                 *_ret = ret;
1165
1166         return 0;
1167 }
1168
1169 Job *manager_get_job(Manager *m, uint32_t id) {
1170         assert(m);
1171
1172         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1173 }
1174
1175 Unit *manager_get_unit(Manager *m, const char *name) {
1176         assert(m);
1177         assert(name);
1178
1179         return hashmap_get(m->units, name);
1180 }
1181
1182 unsigned manager_dispatch_load_queue(Manager *m) {
1183         Meta *meta;
1184         unsigned n = 0;
1185
1186         assert(m);
1187
1188         /* Make sure we are not run recursively */
1189         if (m->dispatching_load_queue)
1190                 return 0;
1191
1192         m->dispatching_load_queue = true;
1193
1194         /* Dispatches the load queue. Takes a unit from the queue and
1195          * tries to load its data until the queue is empty */
1196
1197         while ((meta = m->load_queue)) {
1198                 assert(meta->in_load_queue);
1199
1200                 unit_load(UNIT(meta));
1201                 n++;
1202         }
1203
1204         m->dispatching_load_queue = false;
1205         return n;
1206 }
1207
1208 int manager_load_unit(Manager *m, const char *path, Unit **_ret) {
1209         Unit *ret;
1210         int r;
1211         const char *name;
1212
1213         assert(m);
1214         assert(path);
1215         assert(_ret);
1216
1217         /* This will load the service information files, but not actually
1218          * start any services or anything. */
1219
1220         name = file_name_from_path(path);
1221
1222         if ((ret = manager_get_unit(m, name))) {
1223                 *_ret = ret;
1224                 return 0;
1225         }
1226
1227         if (!(ret = unit_new(m)))
1228                 return -ENOMEM;
1229
1230         if (is_path(path)) {
1231                 if (!(ret->meta.fragment_path = strdup(path))) {
1232                         unit_free(ret);
1233                         return -ENOMEM;
1234                 }
1235         }
1236
1237         if ((r = unit_add_name(ret, name)) < 0) {
1238                 unit_free(ret);
1239                 return r;
1240         }
1241
1242         unit_add_to_load_queue(ret);
1243         unit_add_to_dbus_queue(ret);
1244
1245         manager_dispatch_load_queue(m);
1246
1247         *_ret = ret;
1248         return 0;
1249 }
1250
1251 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1252         Iterator i;
1253         Job *j;
1254
1255         assert(s);
1256         assert(f);
1257
1258         HASHMAP_FOREACH(j, s->jobs, i)
1259                 job_dump(j, f, prefix);
1260 }
1261
1262 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1263         Iterator i;
1264         Unit *u;
1265         const char *t;
1266
1267         assert(s);
1268         assert(f);
1269
1270         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1271                 if (unit_id(u) == t)
1272                         unit_dump(u, f, prefix);
1273 }
1274
1275 void manager_clear_jobs(Manager *m) {
1276         Job *j;
1277
1278         assert(m);
1279
1280         transaction_abort(m);
1281
1282         while ((j = hashmap_first(m->jobs)))
1283                 job_free(j);
1284 }
1285
1286 unsigned manager_dispatch_run_queue(Manager *m) {
1287         Job *j;
1288         unsigned n = 0;
1289
1290         if (m->dispatching_run_queue)
1291                 return 0;
1292
1293         m->dispatching_run_queue = true;
1294
1295         while ((j = m->run_queue)) {
1296                 assert(j->installed);
1297                 assert(j->in_run_queue);
1298
1299                 job_run_and_invalidate(j);
1300                 n++;
1301         }
1302
1303         m->dispatching_run_queue = false;
1304         return n;
1305 }
1306
1307 unsigned manager_dispatch_dbus_queue(Manager *m) {
1308         Job *j;
1309         Meta *meta;
1310         unsigned n = 0;
1311
1312         assert(m);
1313
1314         if (m->dispatching_dbus_queue)
1315                 return 0;
1316
1317         m->dispatching_dbus_queue = true;
1318
1319         while ((meta = m->dbus_unit_queue)) {
1320                 Unit *u = (Unit*) meta;
1321                 assert(u->meta.in_dbus_queue);
1322
1323                 bus_unit_send_change_signal(u);
1324                 n++;
1325         }
1326
1327         while ((j = m->dbus_job_queue)) {
1328                 assert(j->in_dbus_queue);
1329
1330                 bus_job_send_change_signal(j);
1331                 n++;
1332         }
1333
1334         m->dispatching_dbus_queue = false;
1335         return n;
1336 }
1337
1338 static int manager_dispatch_sigchld(Manager *m) {
1339         assert(m);
1340
1341         log_debug("dispatching SIGCHLD");
1342
1343         for (;;) {
1344                 siginfo_t si;
1345                 Unit *u;
1346
1347                 zero(si);
1348                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG) < 0) {
1349
1350                         if (errno == ECHILD)
1351                                 break;
1352
1353                         return -errno;
1354                 }
1355
1356                 if (si.si_pid == 0)
1357                         break;
1358
1359                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1360                         continue;
1361
1362                 log_debug("child %llu died (code=%s, status=%i)", (long long unsigned) si.si_pid, sigchld_code_to_string(si.si_code), si.si_status);
1363
1364                 if (!(u = hashmap_remove(m->watch_pids, UINT32_TO_PTR(si.si_pid))))
1365                         continue;
1366
1367                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1368         }
1369
1370         return 0;
1371 }
1372
1373 static int manager_process_signal_fd(Manager *m, bool *quit) {
1374         ssize_t n;
1375         struct signalfd_siginfo sfsi;
1376         bool sigchld = false;
1377
1378         assert(m);
1379
1380         for (;;) {
1381                 if ((n = read(m->signal_watch.fd, &sfsi, sizeof(sfsi))) != sizeof(sfsi)) {
1382
1383                         if (n >= 0)
1384                                 return -EIO;
1385
1386                         if (errno == EAGAIN)
1387                                 break;
1388
1389                         return -errno;
1390                 }
1391
1392                 switch (sfsi.ssi_signo) {
1393
1394                 case SIGCHLD:
1395                         sigchld = true;
1396                         break;
1397
1398                 case SIGINT:
1399                 case SIGTERM:
1400
1401                         if (m->running_as != MANAGER_INIT) {
1402                                 *quit = true;
1403                                 return 0;
1404
1405                         } else {
1406                                 Unit *target;
1407                                 int r;
1408
1409                                 if ((r = manager_load_unit(m, SPECIAL_CTRL_ALT_DEL_TARGET, &target)) < 0)
1410                                         log_error("Failed to load ctrl-alt-del target: %s", strerror(-r));
1411                                 else if ((r = manager_add_job(m, JOB_START, target, JOB_REPLACE, true, NULL)) < 0)
1412                                         log_error("Failed to enqueue ctrl-alt-del job: %s", strerror(-r));
1413
1414                                 break;
1415                         }
1416
1417                 case SIGWINCH:
1418
1419                         if (m->running_as == MANAGER_INIT) {
1420                                 Unit *target;
1421                                 int r;
1422
1423                                 if ((r = manager_load_unit(m, SPECIAL_KBREQUEST_TARGET, &target)) < 0)
1424                                         log_error("Failed to load kbrequest target: %s", strerror(-r));
1425                                 else if ((r = manager_add_job(m, JOB_START, target, JOB_REPLACE, true, NULL)) < 0)
1426                                         log_error("Failed to enqueue kbrequest job: %s", strerror(-r));
1427
1428                                 break;
1429                         }
1430
1431                         /* This is a nop on non-init systemd's */
1432
1433                         break;
1434
1435                 default:
1436                         log_info("Got unhandled signal <%s>.", strsignal(sfsi.ssi_signo));
1437                 }
1438         }
1439
1440         if (sigchld)
1441                 return manager_dispatch_sigchld(m);
1442
1443         return 0;
1444 }
1445
1446 static int process_event(Manager *m, struct epoll_event *ev, bool *quit) {
1447         int r;
1448         Watch *w;
1449
1450         assert(m);
1451         assert(ev);
1452
1453         assert(w = ev->data.ptr);
1454
1455         switch (w->type) {
1456
1457         case WATCH_SIGNAL:
1458
1459                 /* An incoming signal? */
1460                 if (ev->events != EPOLLIN)
1461                         return -EINVAL;
1462
1463                 if ((r = manager_process_signal_fd(m, quit)) < 0)
1464                         return r;
1465
1466                 break;
1467
1468         case WATCH_FD:
1469
1470                 /* Some fd event, to be dispatched to the units */
1471                 UNIT_VTABLE(w->data.unit)->fd_event(w->data.unit, w->fd, ev->events, w);
1472                 break;
1473
1474         case WATCH_TIMER: {
1475                 uint64_t v;
1476                 ssize_t k;
1477
1478                 /* Some timer event, to be dispatched to the units */
1479                 if ((k = read(w->fd, &v, sizeof(v))) != sizeof(v)) {
1480
1481                         if (k < 0 && (errno == EINTR || errno == EAGAIN))
1482                                 break;
1483
1484                         return k < 0 ? -errno : -EIO;
1485                 }
1486
1487                 UNIT_VTABLE(w->data.unit)->timer_event(w->data.unit, v, w);
1488                 break;
1489         }
1490
1491         case WATCH_MOUNT:
1492                 /* Some mount table change, intended for the mount subsystem */
1493                 mount_fd_event(m, ev->events);
1494                 break;
1495
1496         case WATCH_UDEV:
1497                 /* Some notification from udev, intended for the device subsystem */
1498                 device_fd_event(m, ev->events);
1499                 break;
1500
1501         case WATCH_DBUS_WATCH:
1502                 bus_watch_event(m, w, ev->events);
1503                 break;
1504
1505         case WATCH_DBUS_TIMEOUT:
1506                 bus_timeout_event(m, w, ev->events);
1507                 break;
1508
1509         default:
1510                 assert_not_reached("Unknown epoll event type.");
1511         }
1512
1513         return 0;
1514 }
1515
1516 int manager_loop(Manager *m) {
1517         int r;
1518         bool quit = false;
1519
1520         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 1000);
1521
1522         assert(m);
1523
1524         for (;;) {
1525                 struct epoll_event event;
1526                 int n;
1527
1528                 if (!ratelimit_test(&rl)) {
1529                         /* Yay, something is going seriously wrong, pause a little */
1530                         log_warning("Looping too fast. Throttling execution a little.");
1531                         sleep(1);
1532                 }
1533
1534                 if (manager_dispatch_load_queue(m) > 0)
1535                         continue;
1536
1537                 if (manager_dispatch_run_queue(m) > 0)
1538                         continue;
1539
1540                 if (bus_dispatch(m) > 0)
1541                         continue;
1542
1543                 if (manager_dispatch_dbus_queue(m) > 0)
1544                         continue;
1545
1546                 if ((n = epoll_wait(m->epoll_fd, &event, 1, -1)) < 0) {
1547
1548                         if (errno == -EINTR)
1549                                 continue;
1550
1551                         return -errno;
1552                 }
1553
1554                 assert(n == 1);
1555
1556                 if ((r = process_event(m, &event, &quit)) < 0)
1557                         return r;
1558
1559                 if (quit)
1560                         return 0;
1561         }
1562 }
1563
1564 int manager_get_unit_from_dbus_path(Manager *m, const char *s, Unit **_u) {
1565         char *n;
1566         Unit *u;
1567
1568         assert(m);
1569         assert(s);
1570         assert(_u);
1571
1572         if (!startswith(s, "/org/freedesktop/systemd1/unit/"))
1573                 return -EINVAL;
1574
1575         if (!(n = bus_path_unescape(s+31)))
1576                 return -ENOMEM;
1577
1578         u = manager_get_unit(m, n);
1579         free(n);
1580
1581         if (!u)
1582                 return -ENOENT;
1583
1584         *_u = u;
1585
1586         return 0;
1587 }
1588
1589 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1590         Job *j;
1591         unsigned id;
1592         int r;
1593
1594         assert(m);
1595         assert(s);
1596         assert(_j);
1597
1598         if (!startswith(s, "/org/freedesktop/systemd1/job/"))
1599                 return -EINVAL;
1600
1601         if ((r = safe_atou(s + 30, &id)) < 0)
1602                 return r;
1603
1604         if (!(j = manager_get_job(m, id)))
1605                 return -ENOENT;
1606
1607         *_j = j;
1608
1609         return 0;
1610 }
1611
1612 static const char* const manager_running_as_table[_MANAGER_RUNNING_AS_MAX] = {
1613         [MANAGER_INIT] = "init",
1614         [MANAGER_SYSTEM] = "system",
1615         [MANAGER_SESSION] = "session"
1616 };
1617
1618 DEFINE_STRING_TABLE_LOOKUP(manager_running_as, ManagerRunningAs);