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