src/core/unit.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 <sys/timerfd.h>
  27 #include <sys/poll.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <sys/stat.h>
  31
  32 #include "sd-id128.h"
  33 #include "sd-messages.h"
  34 #include "set.h"
  35 #include "unit.h"
  36 #include "macro.h"
  37 #include "strv.h"
  38 #include "path-util.h"
  39 #include "load-fragment.h"
  40 #include "load-dropin.h"
  41 #include "log.h"
  42 #include "unit-name.h"
  43 #include "dbus-unit.h"
  44 #include "special.h"
  45 #include "cgroup-util.h"
  46 #include "missing.h"
  47 #include "mkdir.h"
  48 #include "label.h"
  49 #include "fileio-label.h"
  50 #include "bus-errors.h"
  51 #include "dbus.h"
  52 #include "execute.h"
  53 #include "virt.h"
  54 #include "dropin.h"
  55
  56 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
  57         [UNIT_SERVICE] = &service_vtable,
  58         [UNIT_SOCKET] = &socket_vtable,
  59         [UNIT_BUSNAME] = &busname_vtable,
  60         [UNIT_TARGET] = &target_vtable,
  61         [UNIT_SNAPSHOT] = &snapshot_vtable,
  62         [UNIT_DEVICE] = &device_vtable,
  63         [UNIT_MOUNT] = &mount_vtable,
  64         [UNIT_AUTOMOUNT] = &automount_vtable,
  65         [UNIT_SWAP] = &swap_vtable,
  66         [UNIT_TIMER] = &timer_vtable,
  67         [UNIT_PATH] = &path_vtable,
  68         [UNIT_SLICE] = &slice_vtable,
  69         [UNIT_SCOPE] = &scope_vtable
  70 };
  71
  72 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency);
  73
  74 Unit *unit_new(Manager *m, size_t size) {
  75         Unit *u;
  76
  77         assert(m);
  78         assert(size >= sizeof(Unit));
  79
  80         u = malloc0(size);
  81         if (!u)
  82                 return NULL;
  83
  84         u->names = set_new(&string_hash_ops);
  85         if (!u->names) {
  86                 free(u);
  87                 return NULL;
  88         }
  89
  90         u->manager = m;
  91         u->type = _UNIT_TYPE_INVALID;
  92         u->deserialized_job = _JOB_TYPE_INVALID;
  93         u->default_dependencies = true;
  94         u->unit_file_state = _UNIT_FILE_STATE_INVALID;
  95         u->on_failure_job_mode = JOB_REPLACE;
  96
  97         return u;
  98 }
  99
 100 bool unit_has_name(Unit *u, const char *name) {
 101         assert(u);
 102         assert(name);
 103
 104         return !!set_get(u->names, (char*) name);
 105 }
 106
 107 static void unit_init(Unit *u) {
 108         CGroupContext *cc;
 109         ExecContext *ec;
 110         KillContext *kc;
 111
 112         assert(u);
 113         assert(u->manager);
 114         assert(u->type >= 0);
 115
 116         cc = unit_get_cgroup_context(u);
 117         if (cc) {
 118                 cgroup_context_init(cc);
 119
 120                 /* Copy in the manager defaults into the cgroup
 121                  * context, _before_ the rest of the settings have
 122                  * been initialized */
 123
 124                 cc->cpu_accounting = u->manager->default_cpu_accounting;
 125                 cc->blockio_accounting = u->manager->default_blockio_accounting;
 126                 cc->memory_accounting = u->manager->default_memory_accounting;
 127         }
 128
 129         ec = unit_get_exec_context(u);
 130         if (ec)
 131                 exec_context_init(ec);
 132
 133         kc = unit_get_kill_context(u);
 134         if (kc)
 135                 kill_context_init(kc);
 136
 137         if (UNIT_VTABLE(u)->init)
 138                 UNIT_VTABLE(u)->init(u);
 139 }
 140
 141 int unit_add_name(Unit *u, const char *text) {
 142         _cleanup_free_ char *s = NULL, *i = NULL;
 143         UnitType t;
 144         int r;
 145
 146         assert(u);
 147         assert(text);
 148
 149         if (unit_name_is_template(text)) {
 150
 151                 if (!u->instance)
 152                         return -EINVAL;
 153
 154                 s = unit_name_replace_instance(text, u->instance);
 155         } else
 156                 s = strdup(text);
 157         if (!s)
 158                 return -ENOMEM;
 159
 160         if (!unit_name_is_valid(s, TEMPLATE_INVALID))
 161                 return -EINVAL;
 162
 163         assert_se((t = unit_name_to_type(s)) >= 0);
 164
 165         if (u->type != _UNIT_TYPE_INVALID && t != u->type)
 166                 return -EINVAL;
 167
 168         r = unit_name_to_instance(s, &i);
 169         if (r < 0)
 170                 return r;
 171
 172         if (i && unit_vtable[t]->no_instances)
 173                 return -EINVAL;
 174
 175         /* Ensure that this unit is either instanced or not instanced,
 176          * but not both. */
 177         if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
 178                 return -EINVAL;
 179
 180         if (unit_vtable[t]->no_alias &&
 181             !set_isempty(u->names) &&
 182             !set_get(u->names, s))
 183                 return -EEXIST;
 184
 185         if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
 186                 return -E2BIG;
 187
 188         r = set_put(u->names, s);
 189         if (r < 0) {
 190                 if (r == -EEXIST)
 191                         return 0;
 192
 193                 return r;
 194         }
 195
 196         r = hashmap_put(u->manager->units, s, u);
 197         if (r < 0) {
 198                 set_remove(u->names, s);
 199                 return r;
 200         }
 201
 202         if (u->type == _UNIT_TYPE_INVALID) {
 203                 u->type = t;
 204                 u->id = s;
 205                 u->instance = i;
 206
 207                 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
 208
 209                 unit_init(u);
 210
 211                 i = NULL;
 212         }
 213
 214         s = NULL;
 215
 216         unit_add_to_dbus_queue(u);
 217         return 0;
 218 }
 219
 220 int unit_choose_id(Unit *u, const char *name) {
 221         _cleanup_free_ char *t = NULL;
 222         char *s, *i;
 223         int r;
 224
 225         assert(u);
 226         assert(name);
 227
 228         if (unit_name_is_template(name)) {
 229
 230                 if (!u->instance)
 231                         return -EINVAL;
 232
 233                 t = unit_name_replace_instance(name, u->instance);
 234                 if (!t)
 235                         return -ENOMEM;
 236
 237                 name = t;
 238         }
 239
 240         /* Selects one of the names of this unit as the id */
 241         s = set_get(u->names, (char*) name);
 242         if (!s)
 243                 return -ENOENT;
 244
 245         r = unit_name_to_instance(s, &i);
 246         if (r < 0)
 247                 return r;
 248
 249         u->id = s;
 250
 251         free(u->instance);
 252         u->instance = i;
 253
 254         unit_add_to_dbus_queue(u);
 255
 256         return 0;
 257 }
 258
 259 int unit_set_description(Unit *u, const char *description) {
 260         char *s;
 261
 262         assert(u);
 263
 264         if (isempty(description))
 265                 s = NULL;
 266         else {
 267                 s = strdup(description);
 268                 if (!s)
 269                         return -ENOMEM;
 270         }
 271
 272         free(u->description);
 273         u->description = s;
 274
 275         unit_add_to_dbus_queue(u);
 276         return 0;
 277 }
 278
 279 bool unit_check_gc(Unit *u) {
 280         assert(u);
 281
 282         if (UNIT_VTABLE(u)->no_gc)
 283                 return true;
 284
 285         if (u->no_gc)
 286                 return true;
 287
 288         if (u->job)
 289                 return true;
 290
 291         if (u->nop_job)
 292                 return true;
 293
 294         if (unit_active_state(u) != UNIT_INACTIVE)
 295                 return true;
 296
 297         if (u->refs)
 298                 return true;
 299
 300         if (UNIT_VTABLE(u)->check_gc)
 301                 if (UNIT_VTABLE(u)->check_gc(u))
 302                         return true;
 303
 304         return false;
 305 }
 306
 307 void unit_add_to_load_queue(Unit *u) {
 308         assert(u);
 309         assert(u->type != _UNIT_TYPE_INVALID);
 310
 311         if (u->load_state != UNIT_STUB || u->in_load_queue)
 312                 return;
 313
 314         LIST_PREPEND(load_queue, u->manager->load_queue, u);
 315         u->in_load_queue = true;
 316 }
 317
 318 void unit_add_to_cleanup_queue(Unit *u) {
 319         assert(u);
 320
 321         if (u->in_cleanup_queue)
 322                 return;
 323
 324         LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
 325         u->in_cleanup_queue = true;
 326 }
 327
 328 void unit_add_to_gc_queue(Unit *u) {
 329         assert(u);
 330
 331         if (u->in_gc_queue || u->in_cleanup_queue)
 332                 return;
 333
 334         if (unit_check_gc(u))
 335                 return;
 336
 337         LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
 338         u->in_gc_queue = true;
 339
 340         u->manager->n_in_gc_queue ++;
 341 }
 342
 343 void unit_add_to_dbus_queue(Unit *u) {
 344         assert(u);
 345         assert(u->type != _UNIT_TYPE_INVALID);
 346
 347         if (u->load_state == UNIT_STUB || u->in_dbus_queue)
 348                 return;
 349
 350         /* Shortcut things if nobody cares */
 351         if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
 352             set_isempty(u->manager->private_buses)) {
 353                 u->sent_dbus_new_signal = true;
 354                 return;
 355         }
 356
 357         LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
 358         u->in_dbus_queue = true;
 359 }
 360
 361 static void bidi_set_free(Unit *u, Set *s) {
 362         Iterator i;
 363         Unit *other;
 364
 365         assert(u);
 366
 367         /* Frees the set and makes sure we are dropped from the
 368          * inverse pointers */
 369
 370         SET_FOREACH(other, s, i) {
 371                 UnitDependency d;
 372
 373                 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 374                         set_remove(other->dependencies[d], u);
 375
 376                 unit_add_to_gc_queue(other);
 377         }
 378
 379         set_free(s);
 380 }
 381
 382 static void unit_remove_transient(Unit *u) {
 383         char **i;
 384
 385         assert(u);
 386
 387         if (!u->transient)
 388                 return;
 389
 390         if (u->fragment_path)
 391                 unlink(u->fragment_path);
 392
 393         STRV_FOREACH(i, u->dropin_paths) {
 394                 _cleanup_free_ char *p = NULL;
 395                 int r;
 396
 397                 unlink(*i);
 398
 399                 r = path_get_parent(*i, &p);
 400                 if (r >= 0)
 401                         rmdir(p);
 402         }
 403 }
 404
 405 static void unit_free_requires_mounts_for(Unit *u) {
 406         char **j;
 407
 408         STRV_FOREACH(j, u->requires_mounts_for) {
 409                 char s[strlen(*j) + 1];
 410
 411                 PATH_FOREACH_PREFIX_MORE(s, *j) {
 412                         char *y;
 413                         Set *x;
 414
 415                         x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
 416                         if (!x)
 417                                 continue;
 418
 419                         set_remove(x, u);
 420
 421                         if (set_isempty(x)) {
 422                                 hashmap_remove(u->manager->units_requiring_mounts_for, y);
 423                                 free(y);
 424                                 set_free(x);
 425                         }
 426                 }
 427         }
 428
 429         strv_free(u->requires_mounts_for);
 430         u->requires_mounts_for = NULL;
 431 }
 432
 433 static void unit_done(Unit *u) {
 434         ExecContext *ec;
 435         CGroupContext *cc;
 436
 437         assert(u);
 438
 439         if (u->type < 0)
 440                 return;
 441
 442         if (UNIT_VTABLE(u)->done)
 443                 UNIT_VTABLE(u)->done(u);
 444
 445         ec = unit_get_exec_context(u);
 446         if (ec)
 447                 exec_context_done(ec);
 448
 449         cc = unit_get_cgroup_context(u);
 450         if (cc)
 451                 cgroup_context_done(cc);
 452 }
 453
 454 void unit_free(Unit *u) {
 455         UnitDependency d;
 456         Iterator i;
 457         char *t;
 458
 459         assert(u);
 460
 461         if (u->manager->n_reloading <= 0)
 462                 unit_remove_transient(u);
 463
 464         bus_unit_send_removed_signal(u);
 465
 466         unit_done(u);
 467
 468         unit_free_requires_mounts_for(u);
 469
 470         SET_FOREACH(t, u->names, i)
 471                 hashmap_remove_value(u->manager->units, t, u);
 472
 473         if (u->job) {
 474                 Job *j = u->job;
 475                 job_uninstall(j);
 476                 job_free(j);
 477         }
 478
 479         if (u->nop_job) {
 480                 Job *j = u->nop_job;
 481                 job_uninstall(j);
 482                 job_free(j);
 483         }
 484
 485         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 486                 bidi_set_free(u, u->dependencies[d]);
 487
 488         if (u->type != _UNIT_TYPE_INVALID)
 489                 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
 490
 491         if (u->in_load_queue)
 492                 LIST_REMOVE(load_queue, u->manager->load_queue, u);
 493
 494         if (u->in_dbus_queue)
 495                 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
 496
 497         if (u->in_cleanup_queue)
 498                 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
 499
 500         if (u->in_gc_queue) {
 501                 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
 502                 u->manager->n_in_gc_queue--;
 503         }
 504
 505         if (u->in_cgroup_queue)
 506                 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
 507
 508         if (u->cgroup_path) {
 509                 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
 510                 free(u->cgroup_path);
 511         }
 512
 513         set_remove(u->manager->failed_units, u);
 514         set_remove(u->manager->startup_units, u);
 515
 516         free(u->description);
 517         strv_free(u->documentation);
 518         free(u->fragment_path);
 519         free(u->source_path);
 520         strv_free(u->dropin_paths);
 521         free(u->instance);
 522
 523         free(u->job_timeout_reboot_arg);
 524
 525         set_free_free(u->names);
 526
 527         unit_unwatch_all_pids(u);
 528
 529         condition_free_list(u->conditions);
 530         condition_free_list(u->asserts);
 531
 532         unit_ref_unset(&u->slice);
 533
 534         while (u->refs)
 535                 unit_ref_unset(u->refs);
 536
 537         free(u);
 538 }
 539
 540 UnitActiveState unit_active_state(Unit *u) {
 541         assert(u);
 542
 543         if (u->load_state == UNIT_MERGED)
 544                 return unit_active_state(unit_follow_merge(u));
 545
 546         /* After a reload it might happen that a unit is not correctly
 547          * loaded but still has a process around. That's why we won't
 548          * shortcut failed loading to UNIT_INACTIVE_FAILED. */
 549
 550         return UNIT_VTABLE(u)->active_state(u);
 551 }
 552
 553 const char* unit_sub_state_to_string(Unit *u) {
 554         assert(u);
 555
 556         return UNIT_VTABLE(u)->sub_state_to_string(u);
 557 }
 558
 559 static int complete_move(Set **s, Set **other) {
 560         int r;
 561
 562         assert(s);
 563         assert(other);
 564
 565         if (!*other)
 566                 return 0;
 567
 568         if (*s) {
 569                 r = set_move(*s, *other);
 570                 if (r < 0)
 571                         return r;
 572         } else {
 573                 *s = *other;
 574                 *other = NULL;
 575         }
 576
 577         return 0;
 578 }
 579
 580 static int merge_names(Unit *u, Unit *other) {
 581         char *t;
 582         Iterator i;
 583         int r;
 584
 585         assert(u);
 586         assert(other);
 587
 588         r = complete_move(&u->names, &other->names);
 589         if (r < 0)
 590                 return r;
 591
 592         set_free_free(other->names);
 593         other->names = NULL;
 594         other->id = NULL;
 595
 596         SET_FOREACH(t, u->names, i)
 597                 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
 598
 599         return 0;
 600 }
 601
 602 static int reserve_dependencies(Unit *u, Unit *other, UnitDependency d) {
 603         unsigned n_reserve;
 604
 605         assert(u);
 606         assert(other);
 607         assert(d < _UNIT_DEPENDENCY_MAX);
 608
 609         /*
 610          * If u does not have this dependency set allocated, there is no need
 611          * to reserve anything. In that case other's set will be transfered
 612          * as a whole to u by complete_move().
 613          */
 614         if (!u->dependencies[d])
 615                 return 0;
 616
 617         /* merge_dependencies() will skip a u-on-u dependency */
 618         n_reserve = set_size(other->dependencies[d]) - !!set_get(other->dependencies[d], u);
 619
 620         return set_reserve(u->dependencies[d], n_reserve);
 621 }
 622
 623 static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
 624         Iterator i;
 625         Unit *back;
 626         int r;
 627
 628         assert(u);
 629         assert(other);
 630         assert(d < _UNIT_DEPENDENCY_MAX);
 631
 632         /* Fix backwards pointers */
 633         SET_FOREACH(back, other->dependencies[d], i) {
 634                 UnitDependency k;
 635
 636                 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
 637                         /* Do not add dependencies between u and itself */
 638                         if (back == u) {
 639                                 if (set_remove(back->dependencies[k], other))
 640                                         maybe_warn_about_dependency(u->id, other_id, k);
 641                         } else {
 642                                 r = set_remove_and_put(back->dependencies[k], other, u);
 643                                 if (r == -EEXIST)
 644                                         set_remove(back->dependencies[k], other);
 645                                 else
 646                                         assert(r >= 0 || r == -ENOENT);
 647                         }
 648                 }
 649         }
 650
 651         /* Also do not move dependencies on u to itself */
 652         back = set_remove(other->dependencies[d], u);
 653         if (back)
 654                 maybe_warn_about_dependency(u->id, other_id, d);
 655
 656         /* The move cannot fail. The caller must have performed a reservation. */
 657         assert_se(complete_move(&u->dependencies[d], &other->dependencies[d]) == 0);
 658
 659         set_free(other->dependencies[d]);
 660         other->dependencies[d] = NULL;
 661 }
 662
 663 int unit_merge(Unit *u, Unit *other) {
 664         UnitDependency d;
 665         const char *other_id = NULL;
 666         int r;
 667
 668         assert(u);
 669         assert(other);
 670         assert(u->manager == other->manager);
 671         assert(u->type != _UNIT_TYPE_INVALID);
 672
 673         other = unit_follow_merge(other);
 674
 675         if (other == u)
 676                 return 0;
 677
 678         if (u->type != other->type)
 679                 return -EINVAL;
 680
 681         if (!u->instance != !other->instance)
 682                 return -EINVAL;
 683
 684         if (other->load_state != UNIT_STUB &&
 685             other->load_state != UNIT_NOT_FOUND)
 686                 return -EEXIST;
 687
 688         if (other->job)
 689                 return -EEXIST;
 690
 691         if (other->nop_job)
 692                 return -EEXIST;
 693
 694         if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
 695                 return -EEXIST;
 696
 697         if (other->id)
 698                 other_id = strdupa(other->id);
 699
 700         /* Make reservations to ensure merge_dependencies() won't fail */
 701         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
 702                 r = reserve_dependencies(u, other, d);
 703                 /*
 704                  * We don't rollback reservations if we fail. We don't have
 705                  * a way to undo reservations. A reservation is not a leak.
 706                  */
 707                 if (r < 0)
 708                         return r;
 709         }
 710
 711         /* Merge names */
 712         r = merge_names(u, other);
 713         if (r < 0)
 714                 return r;
 715
 716         /* Redirect all references */
 717         while (other->refs)
 718                 unit_ref_set(other->refs, u);
 719
 720         /* Merge dependencies */
 721         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 722                 merge_dependencies(u, other, other_id, d);
 723
 724         other->load_state = UNIT_MERGED;
 725         other->merged_into = u;
 726
 727         /* If there is still some data attached to the other node, we
 728          * don't need it anymore, and can free it. */
 729         if (other->load_state != UNIT_STUB)
 730                 if (UNIT_VTABLE(other)->done)
 731                         UNIT_VTABLE(other)->done(other);
 732
 733         unit_add_to_dbus_queue(u);
 734         unit_add_to_cleanup_queue(other);
 735
 736         return 0;
 737 }
 738
 739 int unit_merge_by_name(Unit *u, const char *name) {
 740         Unit *other;
 741         int r;
 742         _cleanup_free_ char *s = NULL;
 743
 744         assert(u);
 745         assert(name);
 746
 747         if (unit_name_is_template(name)) {
 748                 if (!u->instance)
 749                         return -EINVAL;
 750
 751                 s = unit_name_replace_instance(name, u->instance);
 752                 if (!s)
 753                         return -ENOMEM;
 754
 755                 name = s;
 756         }
 757
 758         other = manager_get_unit(u->manager, name);
 759         if (!other)
 760                 r = unit_add_name(u, name);
 761         else
 762                 r = unit_merge(u, other);
 763
 764         return r;
 765 }
 766
 767 Unit* unit_follow_merge(Unit *u) {
 768         assert(u);
 769
 770         while (u->load_state == UNIT_MERGED)
 771                 assert_se(u = u->merged_into);
 772
 773         return u;
 774 }
 775
 776 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
 777         int r;
 778
 779         assert(u);
 780         assert(c);
 781
 782         if (c->working_directory) {
 783                 r = unit_require_mounts_for(u, c->working_directory);
 784                 if (r < 0)
 785                         return r;
 786         }
 787
 788         if (c->root_directory) {
 789                 r = unit_require_mounts_for(u, c->root_directory);
 790                 if (r < 0)
 791                         return r;
 792         }
 793
 794         if (u->manager->running_as != SYSTEMD_SYSTEM)
 795                 return 0;
 796
 797         if (c->private_tmp) {
 798                 r = unit_require_mounts_for(u, "/tmp");
 799                 if (r < 0)
 800                         return r;
 801
 802                 r = unit_require_mounts_for(u, "/var/tmp");
 803                 if (r < 0)
 804                         return r;
 805         }
 806
 807         if (c->std_output != EXEC_OUTPUT_KMSG &&
 808             c->std_output != EXEC_OUTPUT_SYSLOG &&
 809             c->std_output != EXEC_OUTPUT_JOURNAL &&
 810             c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
 811             c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
 812             c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
 813             c->std_error != EXEC_OUTPUT_KMSG &&
 814             c->std_error != EXEC_OUTPUT_SYSLOG &&
 815             c->std_error != EXEC_OUTPUT_JOURNAL &&
 816             c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
 817             c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
 818             c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
 819                 return 0;
 820
 821         /* If syslog or kernel logging is requested, make sure our own
 822          * logging daemon is run first. */
 823
 824         r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
 825         if (r < 0)
 826                 return r;
 827
 828         return 0;
 829 }
 830
 831 const char *unit_description(Unit *u) {
 832         assert(u);
 833
 834         if (u->description)
 835                 return u->description;
 836
 837         return strna(u->id);
 838 }
 839
 840 void unit_dump(Unit *u, FILE *f, const char *prefix) {
 841         char *t, **j;
 842         UnitDependency d;
 843         Iterator i;
 844         const char *prefix2;
 845         char
 846                 timestamp1[FORMAT_TIMESTAMP_MAX],
 847                 timestamp2[FORMAT_TIMESTAMP_MAX],
 848                 timestamp3[FORMAT_TIMESTAMP_MAX],
 849                 timestamp4[FORMAT_TIMESTAMP_MAX],
 850                 timespan[FORMAT_TIMESPAN_MAX];
 851         Unit *following;
 852         _cleanup_set_free_ Set *following_set = NULL;
 853         int r;
 854
 855         assert(u);
 856         assert(u->type >= 0);
 857
 858         prefix = strempty(prefix);
 859         prefix2 = strappenda(prefix, "\t");
 860
 861         fprintf(f,
 862                 "%s-> Unit %s:\n"
 863                 "%s\tDescription: %s\n"
 864                 "%s\tInstance: %s\n"
 865                 "%s\tUnit Load State: %s\n"
 866                 "%s\tUnit Active State: %s\n"
 867                 "%s\tInactive Exit Timestamp: %s\n"
 868                 "%s\tActive Enter Timestamp: %s\n"
 869                 "%s\tActive Exit Timestamp: %s\n"
 870                 "%s\tInactive Enter Timestamp: %s\n"
 871                 "%s\tGC Check Good: %s\n"
 872                 "%s\tNeed Daemon Reload: %s\n"
 873                 "%s\tTransient: %s\n"
 874                 "%s\tSlice: %s\n"
 875                 "%s\tCGroup: %s\n"
 876                 "%s\tCGroup realized: %s\n"
 877                 "%s\tCGroup mask: 0x%x\n"
 878                 "%s\tCGroup members mask: 0x%x\n",
 879                 prefix, u->id,
 880                 prefix, unit_description(u),
 881                 prefix, strna(u->instance),
 882                 prefix, unit_load_state_to_string(u->load_state),
 883                 prefix, unit_active_state_to_string(unit_active_state(u)),
 884                 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
 885                 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
 886                 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
 887                 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
 888                 prefix, yes_no(unit_check_gc(u)),
 889                 prefix, yes_no(unit_need_daemon_reload(u)),
 890                 prefix, yes_no(u->transient),
 891                 prefix, strna(unit_slice_name(u)),
 892                 prefix, strna(u->cgroup_path),
 893                 prefix, yes_no(u->cgroup_realized),
 894                 prefix, u->cgroup_realized_mask,
 895                 prefix, u->cgroup_members_mask);
 896
 897         SET_FOREACH(t, u->names, i)
 898                 fprintf(f, "%s\tName: %s\n", prefix, t);
 899
 900         STRV_FOREACH(j, u->documentation)
 901                 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
 902
 903         following = unit_following(u);
 904         if (following)
 905                 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
 906
 907         r = unit_following_set(u, &following_set);
 908         if (r >= 0) {
 909                 Unit *other;
 910
 911                 SET_FOREACH(other, following_set, i)
 912                         fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
 913         }
 914
 915         if (u->fragment_path)
 916                 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
 917
 918         if (u->source_path)
 919                 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
 920
 921         STRV_FOREACH(j, u->dropin_paths)
 922                 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
 923
 924         if (u->job_timeout > 0)
 925                 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
 926
 927         if (u->job_timeout_action != FAILURE_ACTION_NONE)
 928                 fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, failure_action_to_string(u->job_timeout_action));
 929
 930         if (u->job_timeout_reboot_arg)
 931                 fprintf(f, "%s\tJob Timeout Reboot Argument: %s\n", prefix, u->job_timeout_reboot_arg);
 932
 933         condition_dump_list(u->conditions, f, prefix, condition_type_to_string);
 934         condition_dump_list(u->asserts, f, prefix, assert_type_to_string);
 935
 936         if (dual_timestamp_is_set(&u->condition_timestamp))
 937                 fprintf(f,
 938                         "%s\tCondition Timestamp: %s\n"
 939                         "%s\tCondition Result: %s\n",
 940                         prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
 941                         prefix, yes_no(u->condition_result));
 942
 943         if (dual_timestamp_is_set(&u->assert_timestamp))
 944                 fprintf(f,
 945                         "%s\tAssert Timestamp: %s\n"
 946                         "%s\tAssert Result: %s\n",
 947                         prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->assert_timestamp.realtime)),
 948                         prefix, yes_no(u->assert_result));
 949
 950         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
 951                 Unit *other;
 952
 953                 SET_FOREACH(other, u->dependencies[d], i)
 954                         fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
 955         }
 956
 957         if (!strv_isempty(u->requires_mounts_for)) {
 958                 fprintf(f,
 959                         "%s\tRequiresMountsFor:", prefix);
 960
 961                 STRV_FOREACH(j, u->requires_mounts_for)
 962                         fprintf(f, " %s", *j);
 963
 964                 fputs("\n", f);
 965         }
 966
 967         if (u->load_state == UNIT_LOADED) {
 968
 969                 fprintf(f,
 970                         "%s\tStopWhenUnneeded: %s\n"
 971                         "%s\tRefuseManualStart: %s\n"
 972                         "%s\tRefuseManualStop: %s\n"
 973                         "%s\tDefaultDependencies: %s\n"
 974                         "%s\tOnFailureJobMode: %s\n"
 975                         "%s\tIgnoreOnIsolate: %s\n"
 976                         "%s\tIgnoreOnSnapshot: %s\n",
 977                         prefix, yes_no(u->stop_when_unneeded),
 978                         prefix, yes_no(u->refuse_manual_start),
 979                         prefix, yes_no(u->refuse_manual_stop),
 980                         prefix, yes_no(u->default_dependencies),
 981                         prefix, job_mode_to_string(u->on_failure_job_mode),
 982                         prefix, yes_no(u->ignore_on_isolate),
 983                         prefix, yes_no(u->ignore_on_snapshot));
 984
 985                 if (UNIT_VTABLE(u)->dump)
 986                         UNIT_VTABLE(u)->dump(u, f, prefix2);
 987
 988         } else if (u->load_state == UNIT_MERGED)
 989                 fprintf(f,
 990                         "%s\tMerged into: %s\n",
 991                         prefix, u->merged_into->id);
 992         else if (u->load_state == UNIT_ERROR)
 993                 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
 994
 995
 996         if (u->job)
 997                 job_dump(u->job, f, prefix2);
 998
 999         if (u->nop_job)
1000                 job_dump(u->nop_job, f, prefix2);
1001
1002 }
1003
1004 /* Common implementation for multiple backends */
1005 int unit_load_fragment_and_dropin(Unit *u) {
1006         int r;
1007
1008         assert(u);
1009
1010         /* Load a .{service,socket,...} file */
1011         r = unit_load_fragment(u);
1012         if (r < 0)
1013                 return r;
1014
1015         if (u->load_state == UNIT_STUB)
1016                 return -ENOENT;
1017
1018         /* Load drop-in directory data */
1019         r = unit_load_dropin(unit_follow_merge(u));
1020         if (r < 0)
1021                 return r;
1022
1023         return 0;
1024 }
1025
1026 /* Common implementation for multiple backends */
1027 int unit_load_fragment_and_dropin_optional(Unit *u) {
1028         int r;
1029
1030         assert(u);
1031
1032         /* Same as unit_load_fragment_and_dropin(), but whether
1033          * something can be loaded or not doesn't matter. */
1034
1035         /* Load a .service file */
1036         r = unit_load_fragment(u);
1037         if (r < 0)
1038                 return r;
1039
1040         if (u->load_state == UNIT_STUB)
1041                 u->load_state = UNIT_LOADED;
1042
1043         /* Load drop-in directory data */
1044         r = unit_load_dropin(unit_follow_merge(u));
1045         if (r < 0)
1046                 return r;
1047
1048         return 0;
1049 }
1050
1051 int unit_add_default_target_dependency(Unit *u, Unit *target) {
1052         assert(u);
1053         assert(target);
1054
1055         if (target->type != UNIT_TARGET)
1056                 return 0;
1057
1058         /* Only add the dependency if both units are loaded, so that
1059          * that loop check below is reliable */
1060         if (u->load_state != UNIT_LOADED ||
1061             target->load_state != UNIT_LOADED)
1062                 return 0;
1063
1064         /* If either side wants no automatic dependencies, then let's
1065          * skip this */
1066         if (!u->default_dependencies ||
1067             !target->default_dependencies)
1068                 return 0;
1069
1070         /* Don't create loops */
1071         if (set_get(target->dependencies[UNIT_BEFORE], u))
1072                 return 0;
1073
1074         return unit_add_dependency(target, UNIT_AFTER, u, true);
1075 }
1076
1077 static int unit_add_target_dependencies(Unit *u) {
1078
1079         static const UnitDependency deps[] = {
1080                 UNIT_REQUIRED_BY,
1081                 UNIT_REQUIRED_BY_OVERRIDABLE,
1082                 UNIT_WANTED_BY,
1083                 UNIT_BOUND_BY
1084         };
1085
1086         Unit *target;
1087         Iterator i;
1088         unsigned k;
1089         int r = 0;
1090
1091         assert(u);
1092
1093         for (k = 0; k < ELEMENTSOF(deps); k++)
1094                 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1095                         r = unit_add_default_target_dependency(u, target);
1096                         if (r < 0)
1097                                 return r;
1098                 }
1099
1100         return r;
1101 }
1102
1103 static int unit_add_slice_dependencies(Unit *u) {
1104         assert(u);
1105
1106         if (!unit_get_cgroup_context(u))
1107                 return 0;
1108
1109         if (UNIT_ISSET(u->slice))
1110                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1111
1112         if (streq(u->id, SPECIAL_ROOT_SLICE))
1113                 return 0;
1114
1115         return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1116 }
1117
1118 static int unit_add_mount_dependencies(Unit *u) {
1119         char **i;
1120         int r;
1121
1122         assert(u);
1123
1124         STRV_FOREACH(i, u->requires_mounts_for) {
1125                 char prefix[strlen(*i) + 1];
1126
1127                 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1128                         Unit *m;
1129
1130                         r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1131                         if (r < 0)
1132                                 return r;
1133                         if (r == 0)
1134                                 continue;
1135                         if (m == u)
1136                                 continue;
1137
1138                         if (m->load_state != UNIT_LOADED)
1139                                 continue;
1140
1141                         r = unit_add_dependency(u, UNIT_AFTER, m, true);
1142                         if (r < 0)
1143                                 return r;
1144
1145                         if (m->fragment_path) {
1146                                 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1147                                 if (r < 0)
1148                                         return r;
1149                         }
1150                 }
1151         }
1152
1153         return 0;
1154 }
1155
1156 static int unit_add_startup_units(Unit *u) {
1157         CGroupContext *c;
1158         int r = 0;
1159
1160         c = unit_get_cgroup_context(u);
1161         if (!c)
1162                 return 0;
1163
1164         if (c->startup_cpu_shares == (unsigned long) -1 &&
1165             c->startup_blockio_weight == (unsigned long) -1)
1166                 return 0;
1167
1168         r = set_put(u->manager->startup_units, u);
1169         if (r == -EEXIST)
1170                 return 0;
1171
1172         return r;
1173 }
1174
1175 int unit_load(Unit *u) {
1176         int r;
1177
1178         assert(u);
1179
1180         if (u->in_load_queue) {
1181                 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1182                 u->in_load_queue = false;
1183         }
1184
1185         if (u->type == _UNIT_TYPE_INVALID)
1186                 return -EINVAL;
1187
1188         if (u->load_state != UNIT_STUB)
1189                 return 0;
1190
1191         if (UNIT_VTABLE(u)->load) {
1192                 r = UNIT_VTABLE(u)->load(u);
1193                 if (r < 0)
1194                         goto fail;
1195         }
1196
1197         if (u->load_state == UNIT_STUB) {
1198                 r = -ENOENT;
1199                 goto fail;
1200         }
1201
1202         if (u->load_state == UNIT_LOADED) {
1203
1204                 r = unit_add_target_dependencies(u);
1205                 if (r < 0)
1206                         goto fail;
1207
1208                 r = unit_add_slice_dependencies(u);
1209                 if (r < 0)
1210                         goto fail;
1211
1212                 r = unit_add_mount_dependencies(u);
1213                 if (r < 0)
1214                         goto fail;
1215
1216                 r = unit_add_startup_units(u);
1217                 if (r < 0)
1218                         goto fail;
1219
1220                 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1221                         log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1222                         r = -EINVAL;
1223                         goto fail;
1224                 }
1225
1226                 unit_update_cgroup_members_masks(u);
1227         }
1228
1229         assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1230
1231         unit_add_to_dbus_queue(unit_follow_merge(u));
1232         unit_add_to_gc_queue(u);
1233
1234         return 0;
1235
1236 fail:
1237         u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1238         u->load_error = r;
1239         unit_add_to_dbus_queue(u);
1240         unit_add_to_gc_queue(u);
1241
1242         log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1243                        u->id, strerror(-r));
1244
1245         return r;
1246 }
1247
1248 static bool unit_condition_test(Unit *u) {
1249         assert(u);
1250
1251         dual_timestamp_get(&u->condition_timestamp);
1252         u->condition_result = condition_test_list(u->id, u->conditions, condition_type_to_string);
1253
1254         return u->condition_result;
1255 }
1256
1257 static bool unit_assert_test(Unit *u) {
1258         assert(u);
1259
1260         dual_timestamp_get(&u->assert_timestamp);
1261         u->assert_result = condition_test_list(u->id, u->asserts, assert_type_to_string);
1262
1263         return u->assert_result;
1264 }
1265
1266 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1267         const UnitStatusMessageFormats *format_table;
1268
1269         assert(u);
1270         assert(t >= 0);
1271         assert(t < _JOB_TYPE_MAX);
1272
1273         if (t != JOB_START && t != JOB_STOP)
1274                 return NULL;
1275
1276         format_table = &UNIT_VTABLE(u)->status_message_formats;
1277         if (!format_table)
1278                 return NULL;
1279
1280         return format_table->starting_stopping[t == JOB_STOP];
1281 }
1282
1283 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1284         const char *format;
1285
1286         assert(u);
1287         assert(t >= 0);
1288         assert(t < _JOB_TYPE_MAX);
1289
1290         format = unit_get_status_message_format(u, t);
1291         if (format)
1292                 return format;
1293
1294         /* Return generic strings */
1295         if (t == JOB_START)
1296                 return "Starting %s.";
1297         else if (t == JOB_STOP)
1298                 return "Stopping %s.";
1299         else if (t == JOB_RELOAD)
1300                 return "Reloading %s.";
1301
1302         return NULL;
1303 }
1304
1305 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1306         const char *format;
1307
1308         assert(u);
1309
1310         /* We only print status messages for selected units on
1311          * selected operations. */
1312
1313         format = unit_get_status_message_format(u, t);
1314         if (!format)
1315                 return;
1316
1317         DISABLE_WARNING_FORMAT_NONLITERAL;
1318         unit_status_printf(u, "", format);
1319         REENABLE_WARNING;
1320 }
1321
1322 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1323         const char *format;
1324         char buf[LINE_MAX];
1325         sd_id128_t mid;
1326
1327         assert(u);
1328
1329         if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1330                 return;
1331
1332         if (log_on_console())
1333                 return;
1334
1335         /* We log status messages for all units and all operations. */
1336
1337         format = unit_get_status_message_format_try_harder(u, t);
1338         if (!format)
1339                 return;
1340
1341         DISABLE_WARNING_FORMAT_NONLITERAL;
1342         snprintf(buf, sizeof(buf), format, unit_description(u));
1343         char_array_0(buf);
1344         REENABLE_WARNING;
1345
1346         mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1347               t == JOB_STOP  ? SD_MESSAGE_UNIT_STOPPING :
1348                                SD_MESSAGE_UNIT_RELOADING;
1349
1350         log_struct_unit(LOG_INFO,
1351                         u->id,
1352                         MESSAGE_ID(mid),
1353                         "MESSAGE=%s", buf,
1354                         NULL);
1355 }
1356
1357 /* Errors:
1358  *         -EBADR:     This unit type does not support starting.
1359  *         -EALREADY:  Unit is already started.
1360  *         -EAGAIN:    An operation is already in progress. Retry later.
1361  *         -ECANCELED: Too many requests for now.
1362  *         -EPROTO:    Assert failed
1363  */
1364 int unit_start(Unit *u) {
1365         UnitActiveState state;
1366         Unit *following;
1367
1368         assert(u);
1369
1370         if (u->load_state != UNIT_LOADED)
1371                 return -EINVAL;
1372
1373         /* If this is already started, then this will succeed. Note
1374          * that this will even succeed if this unit is not startable
1375          * by the user. This is relied on to detect when we need to
1376          * wait for units and when waiting is finished. */
1377         state = unit_active_state(u);
1378         if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1379                 return -EALREADY;
1380
1381         /* If the conditions failed, don't do anything at all. If we
1382          * already are activating this call might still be useful to
1383          * speed up activation in case there is some hold-off time,
1384          * but we don't want to recheck the condition in that case. */
1385         if (state != UNIT_ACTIVATING &&
1386             !unit_condition_test(u)) {
1387                 log_debug_unit(u->id, "Starting of %s requested but condition failed. Not starting unit.", u->id);
1388                 return -EALREADY;
1389         }
1390
1391         /* If the asserts failed, fail the entire job */
1392         if (state != UNIT_ACTIVATING &&
1393             !unit_assert_test(u)) {
1394                 log_debug_unit(u->id, "Starting of %s requested but asserts failed.", u->id);
1395                 return -EPROTO;
1396         }
1397
1398         /* Forward to the main object, if we aren't it. */
1399         following = unit_following(u);
1400         if (following) {
1401                 log_debug_unit(u->id, "Redirecting start request from %s to %s.", u->id, following->id);
1402                 return unit_start(following);
1403         }
1404
1405         unit_status_log_starting_stopping_reloading(u, JOB_START);
1406         unit_status_print_starting_stopping(u, JOB_START);
1407
1408         /* If it is stopped, but we cannot start it, then fail */
1409         if (!UNIT_VTABLE(u)->start)
1410                 return -EBADR;
1411
1412         /* We don't suppress calls to ->start() here when we are
1413          * already starting, to allow this request to be used as a
1414          * "hurry up" call, for example when the unit is in some "auto
1415          * restart" state where it waits for a holdoff timer to elapse
1416          * before it will start again. */
1417
1418         unit_add_to_dbus_queue(u);
1419
1420         return UNIT_VTABLE(u)->start(u);
1421 }
1422
1423 bool unit_can_start(Unit *u) {
1424         assert(u);
1425
1426         return !!UNIT_VTABLE(u)->start;
1427 }
1428
1429 bool unit_can_isolate(Unit *u) {
1430         assert(u);
1431
1432         return unit_can_start(u) &&
1433                 u->allow_isolate;
1434 }
1435
1436 /* Errors:
1437  *         -EBADR:    This unit type does not support stopping.
1438  *         -EALREADY: Unit is already stopped.
1439  *         -EAGAIN:   An operation is already in progress. Retry later.
1440  */
1441 int unit_stop(Unit *u) {
1442         UnitActiveState state;
1443         Unit *following;
1444
1445         assert(u);
1446
1447         state = unit_active_state(u);
1448         if (UNIT_IS_INACTIVE_OR_FAILED(state))
1449                 return -EALREADY;
1450
1451         if ((following = unit_following(u))) {
1452                 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1453                                u->id, following->id);
1454                 return unit_stop(following);
1455         }
1456
1457         unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1458         unit_status_print_starting_stopping(u, JOB_STOP);
1459
1460         if (!UNIT_VTABLE(u)->stop)
1461                 return -EBADR;
1462
1463         unit_add_to_dbus_queue(u);
1464
1465         return UNIT_VTABLE(u)->stop(u);
1466 }
1467
1468 /* Errors:
1469  *         -EBADR:    This unit type does not support reloading.
1470  *         -ENOEXEC:  Unit is not started.
1471  *         -EAGAIN:   An operation is already in progress. Retry later.
1472  */
1473 int unit_reload(Unit *u) {
1474         UnitActiveState state;
1475         Unit *following;
1476
1477         assert(u);
1478
1479         if (u->load_state != UNIT_LOADED)
1480                 return -EINVAL;
1481
1482         if (!unit_can_reload(u))
1483                 return -EBADR;
1484
1485         state = unit_active_state(u);
1486         if (state == UNIT_RELOADING)
1487                 return -EALREADY;
1488
1489         if (state != UNIT_ACTIVE) {
1490                 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1491                                  u->id);
1492                 return -ENOEXEC;
1493         }
1494
1495         following = unit_following(u);
1496         if (following) {
1497                 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1498                                u->id, following->id);
1499                 return unit_reload(following);
1500         }
1501
1502         unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1503
1504         unit_add_to_dbus_queue(u);
1505         return UNIT_VTABLE(u)->reload(u);
1506 }
1507
1508 bool unit_can_reload(Unit *u) {
1509         assert(u);
1510
1511         if (!UNIT_VTABLE(u)->reload)
1512                 return false;
1513
1514         if (!UNIT_VTABLE(u)->can_reload)
1515                 return true;
1516
1517         return UNIT_VTABLE(u)->can_reload(u);
1518 }
1519
1520 static void unit_check_unneeded(Unit *u) {
1521         Iterator i;
1522         Unit *other;
1523
1524         assert(u);
1525
1526         /* If this service shall be shut down when unneeded then do
1527          * so. */
1528
1529         if (!u->stop_when_unneeded)
1530                 return;
1531
1532         if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1533                 return;
1534
1535         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1536                 if (unit_active_or_pending(other))
1537                         return;
1538
1539         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1540                 if (unit_active_or_pending(other))
1541                         return;
1542
1543         SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1544                 if (unit_active_or_pending(other))
1545                         return;
1546
1547         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1548                 if (unit_active_or_pending(other))
1549                         return;
1550
1551         log_info_unit(u->id, "Unit %s is not needed anymore. Stopping.", u->id);
1552
1553         /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1554         manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1555 }
1556
1557 static void unit_check_binds_to(Unit *u) {
1558         bool stop = false;
1559         Unit *other;
1560         Iterator i;
1561
1562         assert(u);
1563
1564         if (u->job)
1565                 return;
1566
1567         if (unit_active_state(u) != UNIT_ACTIVE)
1568                 return;
1569
1570         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1571                 if (other->job)
1572                         continue;
1573
1574                 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1575                         continue;
1576
1577                 stop = true;
1578         }
1579
1580         if (!stop)
1581                 return;
1582
1583         log_info_unit(u->id, "Unit %s is bound to inactive service. Stopping, too.", u->id);
1584
1585         /* A unit we need to run is gone. Sniff. Let's stop this. */
1586         manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1587 }
1588
1589 static void retroactively_start_dependencies(Unit *u) {
1590         Iterator i;
1591         Unit *other;
1592
1593         assert(u);
1594         assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1595
1596         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1597                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1598                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1599                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1600
1601         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1602                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1603                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1604                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1605
1606         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1607                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1608                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1609                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1610
1611         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1612                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1613                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1614                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1615
1616         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1617                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1618                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1619
1620         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1621                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1622                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1623 }
1624
1625 static void retroactively_stop_dependencies(Unit *u) {
1626         Iterator i;
1627         Unit *other;
1628
1629         assert(u);
1630         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1631
1632         /* Pull down units which are bound to us recursively if enabled */
1633         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1634                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1635                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1636 }
1637
1638 static void check_unneeded_dependencies(Unit *u) {
1639         Iterator i;
1640         Unit *other;
1641
1642         assert(u);
1643         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1644
1645         /* Garbage collect services that might not be needed anymore, if enabled */
1646         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1647                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1648                         unit_check_unneeded(other);
1649         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1650                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1651                         unit_check_unneeded(other);
1652         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1653                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1654                         unit_check_unneeded(other);
1655         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1656                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1657                         unit_check_unneeded(other);
1658         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1659                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1660                         unit_check_unneeded(other);
1661         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1662                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1663                         unit_check_unneeded(other);
1664 }
1665
1666 void unit_start_on_failure(Unit *u) {
1667         Unit *other;
1668         Iterator i;
1669
1670         assert(u);
1671
1672         if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1673                 return;
1674
1675         log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1676
1677         SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1678                 int r;
1679
1680                 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1681                 if (r < 0)
1682                         log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1683         }
1684 }
1685
1686 void unit_trigger_notify(Unit *u) {
1687         Unit *other;
1688         Iterator i;
1689
1690         assert(u);
1691
1692         SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1693                 if (UNIT_VTABLE(other)->trigger_notify)
1694                         UNIT_VTABLE(other)->trigger_notify(other, u);
1695 }
1696
1697 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1698         Manager *m;
1699         bool unexpected;
1700
1701         assert(u);
1702         assert(os < _UNIT_ACTIVE_STATE_MAX);
1703         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1704
1705         /* Note that this is called for all low-level state changes,
1706          * even if they might map to the same high-level
1707          * UnitActiveState! That means that ns == os is an expected
1708          * behavior here. For example: if a mount point is remounted
1709          * this function will be called too! */
1710
1711         m = u->manager;
1712
1713         /* Update timestamps for state changes */
1714         if (m->n_reloading <= 0) {
1715                 dual_timestamp ts;
1716
1717                 dual_timestamp_get(&ts);
1718
1719                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1720                         u->inactive_exit_timestamp = ts;
1721                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1722                         u->inactive_enter_timestamp = ts;
1723
1724                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1725                         u->active_enter_timestamp = ts;
1726                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1727                         u->active_exit_timestamp = ts;
1728         }
1729
1730         /* Keep track of failed units */
1731         if (ns == UNIT_FAILED)
1732                 set_put(u->manager->failed_units, u);
1733         else
1734                 set_remove(u->manager->failed_units, u);
1735
1736         /* Make sure the cgroup is always removed when we become inactive */
1737         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1738                 unit_destroy_cgroup(u);
1739
1740         /* Note that this doesn't apply to RemainAfterExit services exiting
1741          * successfully, since there's no change of state in that case. Which is
1742          * why it is handled in service_set_state() */
1743         if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1744                 ExecContext *ec;
1745
1746                 ec = unit_get_exec_context(u);
1747                 if (ec && exec_context_may_touch_console(ec)) {
1748                         if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1749                                 m->n_on_console --;
1750
1751                                 if (m->n_on_console == 0)
1752                                         /* unset no_console_output flag, since the console is free */
1753                                         m->no_console_output = false;
1754                         } else
1755                                 m->n_on_console ++;
1756                 }
1757         }
1758
1759         if (u->job) {
1760                 unexpected = false;
1761
1762                 if (u->job->state == JOB_WAITING)
1763
1764                         /* So we reached a different state for this
1765                          * job. Let's see if we can run it now if it
1766                          * failed previously due to EAGAIN. */
1767                         job_add_to_run_queue(u->job);
1768
1769                 /* Let's check whether this state change constitutes a
1770                  * finished job, or maybe contradicts a running job and
1771                  * hence needs to invalidate jobs. */
1772
1773                 switch (u->job->type) {
1774
1775                 case JOB_START:
1776                 case JOB_VERIFY_ACTIVE:
1777
1778                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1779                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1780                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1781                                 unexpected = true;
1782
1783                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1784                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1785                         }
1786
1787                         break;
1788
1789                 case JOB_RELOAD:
1790                 case JOB_RELOAD_OR_START:
1791
1792                         if (u->job->state == JOB_RUNNING) {
1793                                 if (ns == UNIT_ACTIVE)
1794                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1795                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1796                                         unexpected = true;
1797
1798                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1799                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1800                                 }
1801                         }
1802
1803                         break;
1804
1805                 case JOB_STOP:
1806                 case JOB_RESTART:
1807                 case JOB_TRY_RESTART:
1808
1809                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1810                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1811                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1812                                 unexpected = true;
1813                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1814                         }
1815
1816                         break;
1817
1818                 default:
1819                         assert_not_reached("Job type unknown");
1820                 }
1821
1822         } else
1823                 unexpected = true;
1824
1825         if (m->n_reloading <= 0) {
1826
1827                 /* If this state change happened without being
1828                  * requested by a job, then let's retroactively start
1829                  * or stop dependencies. We skip that step when
1830                  * deserializing, since we don't want to create any
1831                  * additional jobs just because something is already
1832                  * activated. */
1833
1834                 if (unexpected) {
1835                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1836                                 retroactively_start_dependencies(u);
1837                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1838                                 retroactively_stop_dependencies(u);
1839                 }
1840
1841                 /* stop unneeded units regardless if going down was expected or not */
1842                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1843                         check_unneeded_dependencies(u);
1844
1845                 if (ns != os && ns == UNIT_FAILED) {
1846                         log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1847                         unit_start_on_failure(u);
1848                 }
1849         }
1850
1851         /* Some names are special */
1852         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1853
1854                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1855                         /* The bus might have just become available,
1856                          * hence try to connect to it, if we aren't
1857                          * yet connected. */
1858                         bus_init(m, true);
1859
1860                 if (u->type == UNIT_SERVICE &&
1861                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1862                     m->n_reloading <= 0) {
1863                         /* Write audit record if we have just finished starting up */
1864                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1865                         u->in_audit = true;
1866                 }
1867
1868                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1869                         manager_send_unit_plymouth(m, u);
1870
1871         } else {
1872
1873                 /* We don't care about D-Bus here, since we'll get an
1874                  * asynchronous notification for it anyway. */
1875
1876                 if (u->type == UNIT_SERVICE &&
1877                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1878                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1879                     m->n_reloading <= 0) {
1880
1881                         /* Hmm, if there was no start record written
1882                          * write it now, so that we always have a nice
1883                          * pair */
1884                         if (!u->in_audit) {
1885                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1886
1887                                 if (ns == UNIT_INACTIVE)
1888                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1889                         } else
1890                                 /* Write audit record if we have just finished shutting down */
1891                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1892
1893                         u->in_audit = false;
1894                 }
1895         }
1896
1897         manager_recheck_journal(m);
1898         unit_trigger_notify(u);
1899
1900         if (u->manager->n_reloading <= 0) {
1901                 /* Maybe we finished startup and are now ready for
1902                  * being stopped because unneeded? */
1903                 unit_check_unneeded(u);
1904
1905                 /* Maybe we finished startup, but something we needed
1906                  * has vanished? Let's die then. (This happens when
1907                  * something BindsTo= to a Type=oneshot unit, as these
1908                  * units go directly from starting to inactive,
1909                  * without ever entering started.) */
1910                 unit_check_binds_to(u);
1911         }
1912
1913         unit_add_to_dbus_queue(u);
1914         unit_add_to_gc_queue(u);
1915 }
1916
1917 int unit_watch_pid(Unit *u, pid_t pid) {
1918         int q, r;
1919
1920         assert(u);
1921         assert(pid >= 1);
1922
1923         /* Watch a specific PID. We only support one or two units
1924          * watching each PID for now, not more. */
1925
1926         r = set_ensure_allocated(&u->pids, NULL);
1927         if (r < 0)
1928                 return r;
1929
1930         r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
1931         if (r < 0)
1932                 return r;
1933
1934         r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1935         if (r == -EEXIST) {
1936                 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
1937                 if (r < 0)
1938                         return r;
1939
1940                 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1941         }
1942
1943         q = set_put(u->pids, LONG_TO_PTR(pid));
1944         if (q < 0)
1945                 return q;
1946
1947         return r;
1948 }
1949
1950 void unit_unwatch_pid(Unit *u, pid_t pid) {
1951         assert(u);
1952         assert(pid >= 1);
1953
1954         hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1955         hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1956         set_remove(u->pids, LONG_TO_PTR(pid));
1957 }
1958
1959 void unit_unwatch_all_pids(Unit *u) {
1960         assert(u);
1961
1962         while (!set_isempty(u->pids))
1963                 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1964
1965         set_free(u->pids);
1966         u->pids = NULL;
1967 }
1968
1969 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1970         _cleanup_closedir_ DIR *d = NULL;
1971         _cleanup_fclose_ FILE *f = NULL;
1972         int ret = 0, r;
1973
1974         assert(u);
1975         assert(path);
1976
1977         /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1978
1979         r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1980         if (r >= 0) {
1981                 pid_t pid;
1982
1983                 while ((r = cg_read_pid(f, &pid)) > 0) {
1984                         r = unit_watch_pid(u, pid);
1985                         if (r < 0 && ret >= 0)
1986                                 ret = r;
1987                 }
1988                 if (r < 0 && ret >= 0)
1989                         ret = r;
1990
1991         } else if (ret >= 0)
1992                 ret = r;
1993
1994         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1995         if (r >= 0) {
1996                 char *fn;
1997
1998                 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1999                         _cleanup_free_ char *p = NULL;
2000
2001                         p = strjoin(path, "/", fn, NULL);
2002                         free(fn);
2003
2004                         if (!p)
2005                                 return -ENOMEM;
2006
2007                         r = unit_watch_pids_in_path(u, p);
2008                         if (r < 0 && ret >= 0)
2009                                 ret = r;
2010                 }
2011                 if (r < 0 && ret >= 0)
2012                         ret = r;
2013
2014         } else if (ret >= 0)
2015                 ret = r;
2016
2017         return ret;
2018 }
2019
2020 int unit_watch_all_pids(Unit *u) {
2021         assert(u);
2022
2023         /* Adds all PIDs from our cgroup to the set of PIDs we watch */
2024
2025         if (!u->cgroup_path)
2026                 return -ENOENT;
2027
2028         return unit_watch_pids_in_path(u, u->cgroup_path);
2029 }
2030
2031 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
2032         Iterator i;
2033         void *e;
2034
2035         assert(u);
2036
2037         /* Cleans dead PIDs from our list */
2038
2039         SET_FOREACH(e, u->pids, i) {
2040                 pid_t pid = PTR_TO_LONG(e);
2041
2042                 if (pid == except1 || pid == except2)
2043                         continue;
2044
2045                 if (!pid_is_unwaited(pid))
2046                         unit_unwatch_pid(u, pid);
2047         }
2048 }
2049
2050 bool unit_job_is_applicable(Unit *u, JobType j) {
2051         assert(u);
2052         assert(j >= 0 && j < _JOB_TYPE_MAX);
2053
2054         switch (j) {
2055
2056         case JOB_VERIFY_ACTIVE:
2057         case JOB_START:
2058         case JOB_STOP:
2059         case JOB_NOP:
2060                 return true;
2061
2062         case JOB_RESTART:
2063         case JOB_TRY_RESTART:
2064                 return unit_can_start(u);
2065
2066         case JOB_RELOAD:
2067                 return unit_can_reload(u);
2068
2069         case JOB_RELOAD_OR_START:
2070                 return unit_can_reload(u) && unit_can_start(u);
2071
2072         default:
2073                 assert_not_reached("Invalid job type");
2074         }
2075 }
2076
2077 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency) {
2078         assert(id);
2079
2080         switch (dependency) {
2081         case UNIT_REQUIRES:
2082         case UNIT_REQUIRES_OVERRIDABLE:
2083         case UNIT_WANTS:
2084         case UNIT_REQUISITE:
2085         case UNIT_REQUISITE_OVERRIDABLE:
2086         case UNIT_BINDS_TO:
2087         case UNIT_PART_OF:
2088         case UNIT_REQUIRED_BY:
2089         case UNIT_REQUIRED_BY_OVERRIDABLE:
2090         case UNIT_WANTED_BY:
2091         case UNIT_BOUND_BY:
2092         case UNIT_CONSISTS_OF:
2093         case UNIT_REFERENCES:
2094         case UNIT_REFERENCED_BY:
2095         case UNIT_PROPAGATES_RELOAD_TO:
2096         case UNIT_RELOAD_PROPAGATED_FROM:
2097         case UNIT_JOINS_NAMESPACE_OF:
2098                 return 0;
2099
2100         case UNIT_CONFLICTS:
2101         case UNIT_CONFLICTED_BY:
2102         case UNIT_BEFORE:
2103         case UNIT_AFTER:
2104         case UNIT_ON_FAILURE:
2105         case UNIT_TRIGGERS:
2106         case UNIT_TRIGGERED_BY:
2107                 if (streq_ptr(id, other))
2108                         log_warning_unit(id, "Dependency %s=%s dropped from unit %s",
2109                                          unit_dependency_to_string(dependency), id, other);
2110                 else
2111                         log_warning_unit(id, "Dependency %s=%s dropped from unit %s merged into %s",
2112                                          unit_dependency_to_string(dependency), id,
2113                                          strna(other), id);
2114                 return -EINVAL;
2115
2116         case _UNIT_DEPENDENCY_MAX:
2117         case _UNIT_DEPENDENCY_INVALID:
2118                 break;
2119         }
2120
2121         assert_not_reached("Invalid dependency type");
2122 }
2123
2124 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2125
2126         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2127                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2128                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2129                 [UNIT_WANTS] = UNIT_WANTED_BY,
2130                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2131                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2132                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2133                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2134                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2135                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2136                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2137                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2138                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2139                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2140                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2141                 [UNIT_BEFORE] = UNIT_AFTER,
2142                 [UNIT_AFTER] = UNIT_BEFORE,
2143                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2144                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2145                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2146                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2147                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2148                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2149                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2150                 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2151         };
2152         int r, q = 0, v = 0, w = 0;
2153         Unit *orig_u = u, *orig_other = other;
2154
2155         assert(u);
2156         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2157         assert(other);
2158
2159         u = unit_follow_merge(u);
2160         other = unit_follow_merge(other);
2161
2162         /* We won't allow dependencies on ourselves. We will not
2163          * consider them an error however. */
2164         if (u == other) {
2165                 maybe_warn_about_dependency(orig_u->id, orig_other->id, d);
2166                 return 0;
2167         }
2168
2169         r = set_ensure_allocated(&u->dependencies[d], NULL);
2170         if (r < 0)
2171                 return r;
2172
2173         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2174                 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2175                 if (r < 0)
2176                         return r;
2177         }
2178
2179         if (add_reference) {
2180                 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2181                 if (r < 0)
2182                         return r;
2183
2184                 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2185                 if (r < 0)
2186                         return r;
2187         }
2188
2189         q = set_put(u->dependencies[d], other);
2190         if (q < 0)
2191                 return q;
2192
2193         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2194                 v = set_put(other->dependencies[inverse_table[d]], u);
2195                 if (v < 0) {
2196                         r = v;
2197                         goto fail;
2198                 }
2199         }
2200
2201         if (add_reference) {
2202                 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2203                 if (w < 0) {
2204                         r = w;
2205                         goto fail;
2206                 }
2207
2208                 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2209                 if (r < 0)
2210                         goto fail;
2211         }
2212
2213         unit_add_to_dbus_queue(u);
2214         return 0;
2215
2216 fail:
2217         if (q > 0)
2218                 set_remove(u->dependencies[d], other);
2219
2220         if (v > 0)
2221                 set_remove(other->dependencies[inverse_table[d]], u);
2222
2223         if (w > 0)
2224                 set_remove(u->dependencies[UNIT_REFERENCES], other);
2225
2226         return r;
2227 }
2228
2229 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2230         int r;
2231
2232         assert(u);
2233
2234         r = unit_add_dependency(u, d, other, add_reference);
2235         if (r < 0)
2236                 return r;
2237
2238         r = unit_add_dependency(u, e, other, add_reference);
2239         if (r < 0)
2240                 return r;
2241
2242         return 0;
2243 }
2244
2245 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2246         char *s;
2247
2248         assert(u);
2249         assert(name || path);
2250         assert(p);
2251
2252         if (!name)
2253                 name = basename(path);
2254
2255         if (!unit_name_is_template(name)) {
2256                 *p = NULL;
2257                 return name;
2258         }
2259
2260         if (u->instance)
2261                 s = unit_name_replace_instance(name, u->instance);
2262         else {
2263                 _cleanup_free_ char *i = NULL;
2264
2265                 i = unit_name_to_prefix(u->id);
2266                 if (!i)
2267                         return NULL;
2268
2269                 s = unit_name_replace_instance(name, i);
2270         }
2271
2272         if (!s)
2273                 return NULL;
2274
2275         *p = s;
2276         return s;
2277 }
2278
2279 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2280         Unit *other;
2281         int r;
2282         _cleanup_free_ char *s = NULL;
2283
2284         assert(u);
2285         assert(name || path);
2286
2287         name = resolve_template(u, name, path, &s);
2288         if (!name)
2289                 return -ENOMEM;
2290
2291         r = manager_load_unit(u->manager, name, path, NULL, &other);
2292         if (r < 0)
2293                 return r;
2294
2295         return unit_add_dependency(u, d, other, add_reference);
2296 }
2297
2298 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2299         _cleanup_free_ char *s = NULL;
2300         Unit *other;
2301         int r;
2302
2303         assert(u);
2304         assert(name || path);
2305
2306         name = resolve_template(u, name, path, &s);
2307         if (!name)
2308                 return -ENOMEM;
2309
2310         r = manager_load_unit(u->manager, name, path, NULL, &other);
2311         if (r < 0)
2312                 return r;
2313
2314         return unit_add_two_dependencies(u, d, e, other, add_reference);
2315 }
2316
2317 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2318         Unit *other;
2319         int r;
2320         _cleanup_free_ char *s = NULL;
2321
2322         assert(u);
2323         assert(name || path);
2324
2325         name = resolve_template(u, name, path, &s);
2326         if (!name)
2327                 return -ENOMEM;
2328
2329         r = manager_load_unit(u->manager, name, path, NULL, &other);
2330         if (r < 0)
2331                 return r;
2332
2333         return unit_add_dependency(other, d, u, add_reference);
2334 }
2335
2336 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2337         Unit *other;
2338         int r;
2339         _cleanup_free_ char *s = NULL;
2340
2341         assert(u);
2342         assert(name || path);
2343
2344         name = resolve_template(u, name, path, &s);
2345         if (!name)
2346                 return -ENOMEM;
2347
2348         r = manager_load_unit(u->manager, name, path, NULL, &other);
2349         if (r < 0)
2350                 return r;
2351
2352         r = unit_add_two_dependencies(other, d, e, u, add_reference);
2353         if (r < 0)
2354                 return r;
2355
2356         return r;
2357 }
2358
2359 int set_unit_path(const char *p) {
2360         /* This is mostly for debug purposes */
2361         if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2362                 return -errno;
2363
2364         return 0;
2365 }
2366
2367 char *unit_dbus_path(Unit *u) {
2368         assert(u);
2369
2370         if (!u->id)
2371                 return NULL;
2372
2373         return unit_dbus_path_from_name(u->id);
2374 }
2375
2376 char *unit_default_cgroup_path(Unit *u) {
2377         _cleanup_free_ char *escaped = NULL, *slice = NULL;
2378         int r;
2379
2380         assert(u);
2381
2382         if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2383                 return strdup(u->manager->cgroup_root);
2384
2385         if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2386                 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2387                 if (r < 0)
2388                         return NULL;
2389         }
2390
2391         escaped = cg_escape(u->id);
2392         if (!escaped)
2393                 return NULL;
2394
2395         if (slice)
2396                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2397         else
2398                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2399 }
2400
2401 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2402         _cleanup_free_ char *b = NULL;
2403         const char *slice_name;
2404         Unit *slice;
2405         int r;
2406
2407         assert(u);
2408         assert(c);
2409
2410         if (UNIT_ISSET(u->slice))
2411                 return 0;
2412
2413         if (u->instance) {
2414                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2415
2416                 /* Implicitly place all instantiated units in their
2417                  * own per-template slice */
2418
2419                 prefix = unit_name_to_prefix(u->id);
2420                 if (!prefix)
2421                         return -ENOMEM;
2422
2423                 /* The prefix is already escaped, but it might include
2424                  * "-" which has a special meaning for slice units,
2425                  * hence escape it here extra. */
2426                 escaped = strreplace(prefix, "-", "\\x2d");
2427                 if (!escaped)
2428                         return -ENOMEM;
2429
2430                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2431                         b = strjoin("system-", escaped, ".slice", NULL);
2432                 else
2433                         b = strappend(escaped, ".slice");
2434                 if (!b)
2435                         return -ENOMEM;
2436
2437                 slice_name = b;
2438         } else
2439                 slice_name =
2440                         u->manager->running_as == SYSTEMD_SYSTEM
2441                         ? SPECIAL_SYSTEM_SLICE
2442                         : SPECIAL_ROOT_SLICE;
2443
2444         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2445         if (r < 0)
2446                 return r;
2447
2448         unit_ref_set(&u->slice, slice);
2449         return 0;
2450 }
2451
2452 const char *unit_slice_name(Unit *u) {
2453         assert(u);
2454
2455         if (!UNIT_ISSET(u->slice))
2456                 return NULL;
2457
2458         return UNIT_DEREF(u->slice)->id;
2459 }
2460
2461 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2462         _cleanup_free_ char *t = NULL;
2463         int r;
2464
2465         assert(u);
2466         assert(type);
2467         assert(_found);
2468
2469         t = unit_name_change_suffix(u->id, type);
2470         if (!t)
2471                 return -ENOMEM;
2472
2473         assert(!unit_has_name(u, t));
2474
2475         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2476         assert(r < 0 || *_found != u);
2477         return r;
2478 }
2479
2480 int unit_watch_bus_name(Unit *u, const char *name) {
2481         assert(u);
2482         assert(name);
2483
2484         /* Watch a specific name on the bus. We only support one unit
2485          * watching each name for now. */
2486
2487         return hashmap_put(u->manager->watch_bus, name, u);
2488 }
2489
2490 void unit_unwatch_bus_name(Unit *u, const char *name) {
2491         assert(u);
2492         assert(name);
2493
2494         hashmap_remove_value(u->manager->watch_bus, name, u);
2495 }
2496
2497 bool unit_can_serialize(Unit *u) {
2498         assert(u);
2499
2500         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2501 }
2502
2503 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2504         int r;
2505
2506         assert(u);
2507         assert(f);
2508         assert(fds);
2509
2510         if (unit_can_serialize(u)) {
2511                 ExecRuntime *rt;
2512
2513                 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2514                 if (r < 0)
2515                         return r;
2516
2517                 rt = unit_get_exec_runtime(u);
2518                 if (rt) {
2519                         r = exec_runtime_serialize(rt, u, f, fds);
2520                         if (r < 0)
2521                                 return r;
2522                 }
2523         }
2524
2525         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2526         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2527         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2528         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2529         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2530         dual_timestamp_serialize(f, "assert-timestamp", &u->assert_timestamp);
2531
2532         if (dual_timestamp_is_set(&u->condition_timestamp))
2533                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2534
2535         if (dual_timestamp_is_set(&u->assert_timestamp))
2536                 unit_serialize_item(u, f, "assert-result", yes_no(u->assert_result));
2537
2538         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2539
2540         if (u->cgroup_path)
2541                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2542
2543         if (serialize_jobs) {
2544                 if (u->job) {
2545                         fprintf(f, "job\n");
2546                         job_serialize(u->job, f, fds);
2547                 }
2548
2549                 if (u->nop_job) {
2550                         fprintf(f, "job\n");
2551                         job_serialize(u->nop_job, f, fds);
2552                 }
2553         }
2554
2555         /* End marker */
2556         fputc('\n', f);
2557         return 0;
2558 }
2559
2560 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2561         va_list ap;
2562
2563         assert(u);
2564         assert(f);
2565         assert(key);
2566         assert(format);
2567
2568         fputs(key, f);
2569         fputc('=', f);
2570
2571         va_start(ap, format);
2572         vfprintf(f, format, ap);
2573         va_end(ap);
2574
2575         fputc('\n', f);
2576 }
2577
2578 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2579         assert(u);
2580         assert(f);
2581         assert(key);
2582         assert(value);
2583
2584         fprintf(f, "%s=%s\n", key, value);
2585 }
2586
2587 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2588         ExecRuntime **rt = NULL;
2589         size_t offset;
2590         int r;
2591
2592         assert(u);
2593         assert(f);
2594         assert(fds);
2595
2596         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2597         if (offset > 0)
2598                 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2599
2600         for (;;) {
2601                 char line[LINE_MAX], *l, *v;
2602                 size_t k;
2603
2604                 if (!fgets(line, sizeof(line), f)) {
2605                         if (feof(f))
2606                                 return 0;
2607                         return -errno;
2608                 }
2609
2610                 char_array_0(line);
2611                 l = strstrip(line);
2612
2613                 /* End marker */
2614                 if (l[0] == 0)
2615                         return 0;
2616
2617                 k = strcspn(l, "=");
2618
2619                 if (l[k] == '=') {
2620                         l[k] = 0;
2621                         v = l+k+1;
2622                 } else
2623                         v = l+k;
2624
2625                 if (streq(l, "job")) {
2626                         if (v[0] == '\0') {
2627                                 /* new-style serialized job */
2628                                 Job *j = job_new_raw(u);
2629                                 if (!j)
2630                                         return -ENOMEM;
2631
2632                                 r = job_deserialize(j, f, fds);
2633                                 if (r < 0) {
2634                                         job_free(j);
2635                                         return r;
2636                                 }
2637
2638                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2639                                 if (r < 0) {
2640                                         job_free(j);
2641                                         return r;
2642                                 }
2643
2644                                 r = job_install_deserialized(j);
2645                                 if (r < 0) {
2646                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2647                                         job_free(j);
2648                                         return r;
2649                                 }
2650
2651                                 if (j->state == JOB_RUNNING)
2652                                         u->manager->n_running_jobs++;
2653                         } else {
2654                                 /* legacy */
2655                                 JobType type = job_type_from_string(v);
2656                                 if (type < 0)
2657                                         log_debug("Failed to parse job type value %s", v);
2658                                 else
2659                                         u->deserialized_job = type;
2660                         }
2661                         continue;
2662                 } else if (streq(l, "inactive-exit-timestamp")) {
2663                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2664                         continue;
2665                 } else if (streq(l, "active-enter-timestamp")) {
2666                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2667                         continue;
2668                 } else if (streq(l, "active-exit-timestamp")) {
2669                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2670                         continue;
2671                 } else if (streq(l, "inactive-enter-timestamp")) {
2672                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2673                         continue;
2674                 } else if (streq(l, "condition-timestamp")) {
2675                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2676                         continue;
2677                 } else if (streq(l, "assert-timestamp")) {
2678                         dual_timestamp_deserialize(v, &u->assert_timestamp);
2679                         continue;
2680                 } else if (streq(l, "condition-result")) {
2681                         int b;
2682
2683                         b = parse_boolean(v);
2684                         if (b < 0)
2685                                 log_debug("Failed to parse condition result value %s", v);
2686                         else
2687                                 u->condition_result = b;
2688
2689                         continue;
2690
2691                 } else if (streq(l, "assert-result")) {
2692                         int b;
2693
2694                         b = parse_boolean(v);
2695                         if (b < 0)
2696                                 log_debug("Failed to parse assert result value %s", v);
2697                         else
2698                                 u->assert_result = b;
2699
2700                         continue;
2701
2702                 } else if (streq(l, "transient")) {
2703                         int b;
2704
2705                         b = parse_boolean(v);
2706                         if (b < 0)
2707                                 log_debug("Failed to parse transient bool %s", v);
2708                         else
2709                                 u->transient = b;
2710
2711                         continue;
2712                 } else if (streq(l, "cgroup")) {
2713                         char *s;
2714
2715                         s = strdup(v);
2716                         if (!s)
2717                                 return -ENOMEM;
2718
2719                         if (u->cgroup_path) {
2720                                 void *p;
2721
2722                                 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2723                                 log_info("Removing cgroup_path %s from hashmap (%p)",
2724                                          u->cgroup_path, p);
2725                                 free(u->cgroup_path);
2726                         }
2727
2728                         u->cgroup_path = s;
2729                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2730
2731                         continue;
2732                 }
2733
2734                 if (unit_can_serialize(u)) {
2735                         if (rt) {
2736                                 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2737                                 if (r < 0)
2738                                         return r;
2739                                 if (r > 0)
2740                                         continue;
2741                         }
2742
2743                         r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2744                         if (r < 0)
2745                                 return r;
2746                 }
2747         }
2748 }
2749
2750 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2751         Unit *device;
2752         _cleanup_free_ char *e = NULL;
2753         int r;
2754
2755         assert(u);
2756
2757         if (!what)
2758                 return 0;
2759
2760         /* Adds in links to the device node that this unit is based on */
2761
2762         if (!is_device_path(what))
2763                 return 0;
2764
2765         e = unit_name_from_path(what, ".device");
2766         if (!e)
2767                 return -ENOMEM;
2768
2769         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2770
2771         if (r < 0)
2772                 return r;
2773
2774         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2775         if (r < 0)
2776                 return r;
2777
2778         if (wants) {
2779                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2780                 if (r < 0)
2781                         return r;
2782         }
2783
2784         return 0;
2785 }
2786
2787 int unit_coldplug(Unit *u) {
2788         int r;
2789
2790         assert(u);
2791
2792         if (UNIT_VTABLE(u)->coldplug)
2793                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2794                         return r;
2795
2796         if (u->job) {
2797                 r = job_coldplug(u->job);
2798                 if (r < 0)
2799                         return r;
2800         } else if (u->deserialized_job >= 0) {
2801                 /* legacy */
2802                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2803                 if (r < 0)
2804                         return r;
2805
2806                 u->deserialized_job = _JOB_TYPE_INVALID;
2807         }
2808
2809         return 0;
2810 }
2811
2812 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2813         DISABLE_WARNING_FORMAT_NONLITERAL;
2814         manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2815                               status, unit_status_msg_format, unit_description(u));
2816         REENABLE_WARNING;
2817 }
2818
2819 bool unit_need_daemon_reload(Unit *u) {
2820         _cleanup_strv_free_ char **t = NULL;
2821         char **path;
2822         struct stat st;
2823         unsigned loaded_cnt, current_cnt;
2824
2825         assert(u);
2826
2827         if (u->fragment_path) {
2828                 zero(st);
2829                 if (stat(u->fragment_path, &st) < 0)
2830                         /* What, cannot access this anymore? */
2831                         return true;
2832
2833                 if (u->fragment_mtime > 0 &&
2834                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2835                         return true;
2836         }
2837
2838         if (u->source_path) {
2839                 zero(st);
2840                 if (stat(u->source_path, &st) < 0)
2841                         return true;
2842
2843                 if (u->source_mtime > 0 &&
2844                     timespec_load(&st.st_mtim) != u->source_mtime)
2845                         return true;
2846         }
2847
2848         t = unit_find_dropin_paths(u);
2849         loaded_cnt = strv_length(t);
2850         current_cnt = strv_length(u->dropin_paths);
2851
2852         if (loaded_cnt == current_cnt) {
2853                 if (loaded_cnt == 0)
2854                         return false;
2855
2856                 if (strv_overlap(u->dropin_paths, t)) {
2857                         STRV_FOREACH(path, u->dropin_paths) {
2858                                 zero(st);
2859                                 if (stat(*path, &st) < 0)
2860                                         return true;
2861
2862                                 if (u->dropin_mtime > 0 &&
2863                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2864                                         return true;
2865                         }
2866
2867                         return false;
2868                 } else
2869                         return true;
2870         } else
2871                 return true;
2872 }
2873
2874 void unit_reset_failed(Unit *u) {
2875         assert(u);
2876
2877         if (UNIT_VTABLE(u)->reset_failed)
2878                 UNIT_VTABLE(u)->reset_failed(u);
2879 }
2880
2881 Unit *unit_following(Unit *u) {
2882         assert(u);
2883
2884         if (UNIT_VTABLE(u)->following)
2885                 return UNIT_VTABLE(u)->following(u);
2886
2887         return NULL;
2888 }
2889
2890 bool unit_stop_pending(Unit *u) {
2891         assert(u);
2892
2893         /* This call does check the current state of the unit. It's
2894          * hence useful to be called from state change calls of the
2895          * unit itself, where the state isn't updated yet. This is
2896          * different from unit_inactive_or_pending() which checks both
2897          * the current state and for a queued job. */
2898
2899         return u->job && u->job->type == JOB_STOP;
2900 }
2901
2902 bool unit_inactive_or_pending(Unit *u) {
2903         assert(u);
2904
2905         /* Returns true if the unit is inactive or going down */
2906
2907         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2908                 return true;
2909
2910         if (unit_stop_pending(u))
2911                 return true;
2912
2913         return false;
2914 }
2915
2916 bool unit_active_or_pending(Unit *u) {
2917         assert(u);
2918
2919         /* Returns true if the unit is active or going up */
2920
2921         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2922                 return true;
2923
2924         if (u->job &&
2925             (u->job->type == JOB_START ||
2926              u->job->type == JOB_RELOAD_OR_START ||
2927              u->job->type == JOB_RESTART))
2928                 return true;
2929
2930         return false;
2931 }
2932
2933 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2934         assert(u);
2935         assert(w >= 0 && w < _KILL_WHO_MAX);
2936         assert(signo > 0);
2937         assert(signo < _NSIG);
2938
2939         if (!UNIT_VTABLE(u)->kill)
2940                 return -ENOTSUP;
2941
2942         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2943 }
2944
2945 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2946         Set *pid_set;
2947         int r;
2948
2949         pid_set = set_new(NULL);
2950         if (!pid_set)
2951                 return NULL;
2952
2953         /* Exclude the main/control pids from being killed via the cgroup */
2954         if (main_pid > 0) {
2955                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2956                 if (r < 0)
2957                         goto fail;
2958         }
2959
2960         if (control_pid > 0) {
2961                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2962                 if (r < 0)
2963                         goto fail;
2964         }
2965
2966         return pid_set;
2967
2968 fail:
2969         set_free(pid_set);
2970         return NULL;
2971 }
2972
2973 int unit_kill_common(
2974                 Unit *u,
2975                 KillWho who,
2976                 int signo,
2977                 pid_t main_pid,
2978                 pid_t control_pid,
2979                 sd_bus_error *error) {
2980
2981         int r = 0;
2982
2983         if (who == KILL_MAIN && main_pid <= 0) {
2984                 if (main_pid < 0)
2985                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2986                 else
2987                         return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2988         }
2989
2990         if (who == KILL_CONTROL && control_pid <= 0) {
2991                 if (control_pid < 0)
2992                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2993                 else
2994                         return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2995         }
2996
2997         if (who == KILL_CONTROL || who == KILL_ALL)
2998                 if (control_pid > 0)
2999                         if (kill(control_pid, signo) < 0)
3000                                 r = -errno;
3001
3002         if (who == KILL_MAIN || who == KILL_ALL)
3003                 if (main_pid > 0)
3004                         if (kill(main_pid, signo) < 0)
3005                                 r = -errno;
3006
3007         if (who == KILL_ALL && u->cgroup_path) {
3008                 _cleanup_set_free_ Set *pid_set = NULL;
3009                 int q;
3010
3011                 /* Exclude the main/control pids from being killed via the cgroup */
3012                 pid_set = unit_pid_set(main_pid, control_pid);
3013                 if (!pid_set)
3014                         return -ENOMEM;
3015
3016                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
3017                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3018                         r = q;
3019         }
3020
3021         return r;
3022 }
3023
3024 int unit_following_set(Unit *u, Set **s) {
3025         assert(u);
3026         assert(s);
3027
3028         if (UNIT_VTABLE(u)->following_set)
3029                 return UNIT_VTABLE(u)->following_set(u, s);
3030
3031         *s = NULL;
3032         return 0;
3033 }
3034
3035 UnitFileState unit_get_unit_file_state(Unit *u) {
3036         assert(u);
3037
3038         if (u->unit_file_state < 0 && u->fragment_path)
3039                 u->unit_file_state = unit_file_get_state(
3040                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3041                                 NULL, basename(u->fragment_path));
3042
3043         return u->unit_file_state;
3044 }
3045
3046 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3047         assert(ref);
3048         assert(u);
3049
3050         if (ref->unit)
3051                 unit_ref_unset(ref);
3052
3053         ref->unit = u;
3054         LIST_PREPEND(refs, u->refs, ref);
3055         return u;
3056 }
3057
3058 void unit_ref_unset(UnitRef *ref) {
3059         assert(ref);
3060
3061         if (!ref->unit)
3062                 return;
3063
3064         LIST_REMOVE(refs, ref->unit->refs, ref);
3065         ref->unit = NULL;
3066 }
3067
3068 int unit_patch_contexts(Unit *u) {
3069         CGroupContext *cc;
3070         ExecContext *ec;
3071         unsigned i;
3072         int r;
3073
3074         assert(u);
3075
3076         /* Patch in the manager defaults into the exec and cgroup
3077          * contexts, _after_ the rest of the settings have been
3078          * initialized */
3079
3080         ec = unit_get_exec_context(u);
3081         if (ec) {
3082                 /* This only copies in the ones that need memory */
3083                 for (i = 0; i < _RLIMIT_MAX; i++)
3084                         if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3085                                 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3086                                 if (!ec->rlimit[i])
3087                                         return -ENOMEM;
3088                         }
3089
3090                 if (u->manager->running_as == SYSTEMD_USER &&
3091                     !ec->working_directory) {
3092
3093                         r = get_home_dir(&ec->working_directory);
3094                         if (r < 0)
3095                                 return r;
3096                 }
3097
3098                 if (u->manager->running_as == SYSTEMD_USER &&
3099                     (ec->syscall_whitelist ||
3100                      !set_isempty(ec->syscall_filter) ||
3101                      !set_isempty(ec->syscall_archs) ||
3102                      ec->address_families_whitelist ||
3103                      !set_isempty(ec->address_families)))
3104                         ec->no_new_privileges = true;
3105
3106                 if (ec->private_devices)
3107                         ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3108         }
3109
3110         cc = unit_get_cgroup_context(u);
3111         if (cc) {
3112
3113                 if (ec &&
3114                     ec->private_devices &&
3115                     cc->device_policy == CGROUP_AUTO)
3116                         cc->device_policy = CGROUP_CLOSED;
3117         }
3118
3119         return 0;
3120 }
3121
3122 ExecContext *unit_get_exec_context(Unit *u) {
3123         size_t offset;
3124         assert(u);
3125
3126         if (u->type < 0)
3127                 return NULL;
3128
3129         offset = UNIT_VTABLE(u)->exec_context_offset;
3130         if (offset <= 0)
3131                 return NULL;
3132
3133         return (ExecContext*) ((uint8_t*) u + offset);
3134 }
3135
3136 KillContext *unit_get_kill_context(Unit *u) {
3137         size_t offset;
3138         assert(u);
3139
3140         if (u->type < 0)
3141                 return NULL;
3142
3143         offset = UNIT_VTABLE(u)->kill_context_offset;
3144         if (offset <= 0)
3145                 return NULL;
3146
3147         return (KillContext*) ((uint8_t*) u + offset);
3148 }
3149
3150 CGroupContext *unit_get_cgroup_context(Unit *u) {
3151         size_t offset;
3152
3153         if (u->type < 0)
3154                 return NULL;
3155
3156         offset = UNIT_VTABLE(u)->cgroup_context_offset;
3157         if (offset <= 0)
3158                 return NULL;
3159
3160         return (CGroupContext*) ((uint8_t*) u + offset);
3161 }
3162
3163 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3164         size_t offset;
3165
3166         if (u->type < 0)
3167                 return NULL;
3168
3169         offset = UNIT_VTABLE(u)->exec_runtime_offset;
3170         if (offset <= 0)
3171                 return NULL;
3172
3173         return *(ExecRuntime**) ((uint8_t*) u + offset);
3174 }
3175
3176 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3177         if (u->manager->running_as == SYSTEMD_USER) {
3178                 int r;
3179
3180                 if (mode == UNIT_PERSISTENT && !transient)
3181                         r = user_config_home(dir);
3182                 else
3183                         r = user_runtime_dir(dir);
3184
3185                 if (r == 0)
3186                         return -ENOENT;
3187                 return r;
3188         }
3189
3190         if (mode == UNIT_PERSISTENT && !transient)
3191                 *dir = strdup("/etc/systemd/system");
3192         else
3193                 *dir = strdup("/run/systemd/system");
3194         if (!*dir)
3195                 return -ENOMEM;
3196
3197         return 0;
3198 }
3199
3200 static int unit_drop_in_file(Unit *u,
3201                              UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3202         _cleanup_free_ char *dir = NULL;
3203         int r;
3204
3205         assert(u);
3206
3207         r = unit_drop_in_dir(u, mode, u->transient, &dir);
3208         if (r < 0)
3209                 return r;
3210
3211         return drop_in_file(dir, u->id, 50, name, p, q);
3212 }
3213
3214 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3215
3216         _cleanup_free_ char *dir = NULL;
3217         int r;
3218
3219         assert(u);
3220
3221         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3222                 return 0;
3223
3224         r = unit_drop_in_dir(u, mode, u->transient, &dir);
3225         if (r < 0)
3226                 return r;
3227
3228         return write_drop_in(dir, u->id, 50, name, data);
3229 }
3230
3231 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3232         _cleanup_free_ char *p = NULL;
3233         va_list ap;
3234         int r;
3235
3236         assert(u);
3237         assert(name);
3238         assert(format);
3239
3240         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3241                 return 0;
3242
3243         va_start(ap, format);
3244         r = vasprintf(&p, format, ap);
3245         va_end(ap);
3246
3247         if (r < 0)
3248                 return -ENOMEM;
3249
3250         return unit_write_drop_in(u, mode, name, p);
3251 }
3252
3253 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3254         _cleanup_free_ char *ndata = NULL;
3255
3256         assert(u);
3257         assert(name);
3258         assert(data);
3259
3260         if (!UNIT_VTABLE(u)->private_section)
3261                 return -EINVAL;
3262
3263         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3264                 return 0;
3265
3266         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3267         if (!ndata)
3268                 return -ENOMEM;
3269
3270         return unit_write_drop_in(u, mode, name, ndata);
3271 }
3272
3273 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3274         _cleanup_free_ char *p = NULL;
3275         va_list ap;
3276         int r;
3277
3278         assert(u);
3279         assert(name);
3280         assert(format);
3281
3282         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3283                 return 0;
3284
3285         va_start(ap, format);
3286         r = vasprintf(&p, format, ap);
3287         va_end(ap);
3288
3289         if (r < 0)
3290                 return -ENOMEM;
3291
3292         return unit_write_drop_in_private(u, mode, name, p);
3293 }
3294
3295 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3296         _cleanup_free_ char *p = NULL, *q = NULL;
3297         int r;
3298
3299         assert(u);
3300
3301         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3302                 return 0;
3303
3304         r = unit_drop_in_file(u, mode, name, &p, &q);
3305         if (r < 0)
3306                 return r;
3307
3308         if (unlink(q) < 0)
3309                 r = errno == ENOENT ? 0 : -errno;
3310         else
3311                 r = 1;
3312
3313         rmdir(p);
3314         return r;
3315 }
3316
3317 int unit_make_transient(Unit *u) {
3318         int r;
3319
3320         assert(u);
3321
3322         u->load_state = UNIT_STUB;
3323         u->load_error = 0;
3324         u->transient = true;
3325
3326         free(u->fragment_path);
3327         u->fragment_path = NULL;
3328
3329         if (u->manager->running_as == SYSTEMD_USER) {
3330                 _cleanup_free_ char *c = NULL;
3331
3332                 r = user_runtime_dir(&c);
3333                 if (r < 0)
3334                         return r;
3335                 if (r == 0)
3336                         return -ENOENT;
3337
3338                 u->fragment_path = strjoin(c, "/", u->id, NULL);
3339                 if (!u->fragment_path)
3340                         return -ENOMEM;
3341
3342                 mkdir_p(c, 0755);
3343         } else {
3344                 u->fragment_path = strappend("/run/systemd/system/", u->id);
3345                 if (!u->fragment_path)
3346                         return -ENOMEM;
3347
3348                 mkdir_p("/run/systemd/system", 0755);
3349         }
3350
3351         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3352 }
3353
3354 int unit_kill_context(
3355                 Unit *u,
3356                 KillContext *c,
3357                 KillOperation k,
3358                 pid_t main_pid,
3359                 pid_t control_pid,
3360                 bool main_pid_alien) {
3361
3362         int sig, wait_for_exit = false, r;
3363
3364         assert(u);
3365         assert(c);
3366
3367         if (c->kill_mode == KILL_NONE)
3368                 return 0;
3369
3370         switch (k) {
3371         case KILL_KILL:
3372                 sig = SIGKILL;
3373                 break;
3374         case KILL_ABORT:
3375                 sig = SIGABRT;
3376                 break;
3377         case KILL_TERMINATE:
3378                 sig = c->kill_signal;
3379                 break;
3380         default:
3381                 assert_not_reached("KillOperation unknown");
3382         }
3383
3384         if (main_pid > 0) {
3385                 r = kill_and_sigcont(main_pid, sig);
3386
3387                 if (r < 0 && r != -ESRCH) {
3388                         _cleanup_free_ char *comm = NULL;
3389                         get_process_comm(main_pid, &comm);
3390
3391                         log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3392                 } else {
3393                         if (!main_pid_alien)
3394                                 wait_for_exit = true;
3395
3396                         if (c->send_sighup && k != KILL_KILL)
3397                                 kill(main_pid, SIGHUP);
3398                 }
3399         }
3400
3401         if (control_pid > 0) {
3402                 r = kill_and_sigcont(control_pid, sig);
3403
3404                 if (r < 0 && r != -ESRCH) {
3405                         _cleanup_free_ char *comm = NULL;
3406                         get_process_comm(control_pid, &comm);
3407
3408                         log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3409                 } else {
3410                         wait_for_exit = true;
3411
3412                         if (c->send_sighup && k != KILL_KILL)
3413                                 kill(control_pid, SIGHUP);
3414                 }
3415         }
3416
3417         if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL)) && u->cgroup_path) {
3418                 _cleanup_set_free_ Set *pid_set = NULL;
3419
3420                 /* Exclude the main/control pids from being killed via the cgroup */
3421                 pid_set = unit_pid_set(main_pid, control_pid);
3422                 if (!pid_set)
3423                         return -ENOMEM;
3424
3425                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3426                 if (r < 0) {
3427                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3428                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3429                 } else if (r > 0) {
3430
3431                         /* FIXME: For now, we will not wait for the
3432                          * cgroup members to die, simply because
3433                          * cgroup notification is unreliable. It
3434                          * doesn't work at all in containers, and
3435                          * outside of containers it can be confused
3436                          * easily by leaving directories in the
3437                          * cgroup. */
3438
3439                         /* wait_for_exit = true; */
3440
3441                         if (c->send_sighup && k != KILL_KILL) {
3442                                 set_free(pid_set);
3443
3444                                 pid_set = unit_pid_set(main_pid, control_pid);
3445                                 if (!pid_set)
3446                                         return -ENOMEM;
3447
3448                                 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3449                         }
3450                 }
3451         }
3452
3453         return wait_for_exit;
3454 }
3455
3456 int unit_require_mounts_for(Unit *u, const char *path) {
3457         char prefix[strlen(path) + 1], *p;
3458         int r;
3459
3460         assert(u);
3461         assert(path);
3462
3463         /* Registers a unit for requiring a certain path and all its
3464          * prefixes. We keep a simple array of these paths in the
3465          * unit, since its usually short. However, we build a prefix
3466          * table for all possible prefixes so that new appearing mount
3467          * units can easily determine which units to make themselves a
3468          * dependency of. */
3469
3470         if (!path_is_absolute(path))
3471                 return -EINVAL;
3472
3473         p = strdup(path);
3474         if (!p)
3475                 return -ENOMEM;
3476
3477         path_kill_slashes(p);
3478
3479         if (!path_is_safe(p)) {
3480                 free(p);
3481                 return -EPERM;
3482         }
3483
3484         if (strv_contains(u->requires_mounts_for, p)) {
3485                 free(p);
3486                 return 0;
3487         }
3488
3489         r = strv_consume(&u->requires_mounts_for, p);
3490         if (r < 0)
3491                 return r;
3492
3493         PATH_FOREACH_PREFIX_MORE(prefix, p) {
3494                 Set *x;
3495
3496                 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3497                 if (!x) {
3498                         char *q;
3499
3500                         if (!u->manager->units_requiring_mounts_for) {
3501                                 u->manager->units_requiring_mounts_for = hashmap_new(&string_hash_ops);
3502                                 if (!u->manager->units_requiring_mounts_for)
3503                                         return -ENOMEM;
3504                         }
3505
3506                         q = strdup(prefix);
3507                         if (!q)
3508                                 return -ENOMEM;
3509
3510                         x = set_new(NULL);
3511                         if (!x) {
3512                                 free(q);
3513                                 return -ENOMEM;
3514                         }
3515
3516                         r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3517                         if (r < 0) {
3518                                 free(q);
3519                                 set_free(x);
3520                                 return r;
3521                         }
3522                 }
3523
3524                 r = set_put(x, u);
3525                 if (r < 0)
3526                         return r;
3527         }
3528
3529         return 0;
3530 }
3531
3532 int unit_setup_exec_runtime(Unit *u) {
3533         ExecRuntime **rt;
3534         size_t offset;
3535         Iterator i;
3536         Unit *other;
3537
3538         offset = UNIT_VTABLE(u)->exec_runtime_offset;
3539         assert(offset > 0);
3540
3541         /* Check if there already is an ExecRuntime for this unit? */
3542         rt = (ExecRuntime**) ((uint8_t*) u + offset);
3543         if (*rt)
3544                 return 0;
3545
3546         /* Try to get it from somebody else */
3547         SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3548
3549                 *rt = unit_get_exec_runtime(other);
3550                 if (*rt) {
3551                         exec_runtime_ref(*rt);
3552                         return 0;
3553                 }
3554         }
3555
3556         return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3557 }
3558
3559 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3560         [UNIT_ACTIVE] = "active",
3561         [UNIT_RELOADING] = "reloading",
3562         [UNIT_INACTIVE] = "inactive",
3563         [UNIT_FAILED] = "failed",
3564         [UNIT_ACTIVATING] = "activating",
3565         [UNIT_DEACTIVATING] = "deactivating"
3566 };
3567
3568 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);