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         manager_update_failed_units(u->manager, u, false);
 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         manager_update_failed_units(u->manager, u, ns == UNIT_FAILED);
1801
1802         /* Make sure the cgroup is always removed when we become inactive */
1803         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1804                 unit_destroy_cgroup_if_empty(u);
1805
1806         /* Note that this doesn't apply to RemainAfterExit services exiting
1807          * successfully, since there's no change of state in that case. Which is
1808          * why it is handled in service_set_state() */
1809         if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1810                 ExecContext *ec;
1811
1812                 ec = unit_get_exec_context(u);
1813                 if (ec && exec_context_may_touch_console(ec)) {
1814                         if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1815                                 m->n_on_console --;
1816
1817                                 if (m->n_on_console == 0)
1818                                         /* unset no_console_output flag, since the console is free */
1819                                         m->no_console_output = false;
1820                         } else
1821                                 m->n_on_console ++;
1822                 }
1823         }
1824
1825         if (u->job) {
1826                 unexpected = false;
1827
1828                 if (u->job->state == JOB_WAITING)
1829
1830                         /* So we reached a different state for this
1831                          * job. Let's see if we can run it now if it
1832                          * failed previously due to EAGAIN. */
1833                         job_add_to_run_queue(u->job);
1834
1835                 /* Let's check whether this state change constitutes a
1836                  * finished job, or maybe contradicts a running job and
1837                  * hence needs to invalidate jobs. */
1838
1839                 switch (u->job->type) {
1840
1841                 case JOB_START:
1842                 case JOB_VERIFY_ACTIVE:
1843
1844                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1845                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1846                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1847                                 unexpected = true;
1848
1849                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1850                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1851                         }
1852
1853                         break;
1854
1855                 case JOB_RELOAD:
1856                 case JOB_RELOAD_OR_START:
1857
1858                         if (u->job->state == JOB_RUNNING) {
1859                                 if (ns == UNIT_ACTIVE)
1860                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1861                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1862                                         unexpected = true;
1863
1864                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1865                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1866                                 }
1867                         }
1868
1869                         break;
1870
1871                 case JOB_STOP:
1872                 case JOB_RESTART:
1873                 case JOB_TRY_RESTART:
1874
1875                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1876                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1877                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1878                                 unexpected = true;
1879                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1880                         }
1881
1882                         break;
1883
1884                 default:
1885                         assert_not_reached("Job type unknown");
1886                 }
1887
1888         } else
1889                 unexpected = true;
1890
1891         if (m->n_reloading <= 0) {
1892
1893                 /* If this state change happened without being
1894                  * requested by a job, then let's retroactively start
1895                  * or stop dependencies. We skip that step when
1896                  * deserializing, since we don't want to create any
1897                  * additional jobs just because something is already
1898                  * activated. */
1899
1900                 if (unexpected) {
1901                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1902                                 retroactively_start_dependencies(u);
1903                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1904                                 retroactively_stop_dependencies(u);
1905                 }
1906
1907                 /* stop unneeded units regardless if going down was expected or not */
1908                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1909                         check_unneeded_dependencies(u);
1910
1911                 if (ns != os && ns == UNIT_FAILED) {
1912                         log_unit_notice(u->id, "Unit %s entered failed state.", u->id);
1913                         unit_start_on_failure(u);
1914                 }
1915         }
1916
1917         /* Some names are special */
1918         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1919
1920                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1921                         /* The bus might have just become available,
1922                          * hence try to connect to it, if we aren't
1923                          * yet connected. */
1924                         bus_init(m, true);
1925
1926                 if (u->type == UNIT_SERVICE &&
1927                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1928                     m->n_reloading <= 0) {
1929                         /* Write audit record if we have just finished starting up */
1930                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1931                         u->in_audit = true;
1932                 }
1933
1934                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1935                         manager_send_unit_plymouth(m, u);
1936
1937         } else {
1938
1939                 /* We don't care about D-Bus here, since we'll get an
1940                  * asynchronous notification for it anyway. */
1941
1942                 if (u->type == UNIT_SERVICE &&
1943                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1944                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1945                     m->n_reloading <= 0) {
1946
1947                         /* Hmm, if there was no start record written
1948                          * write it now, so that we always have a nice
1949                          * pair */
1950                         if (!u->in_audit) {
1951                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1952
1953                                 if (ns == UNIT_INACTIVE)
1954                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1955                         } else
1956                                 /* Write audit record if we have just finished shutting down */
1957                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1958
1959                         u->in_audit = false;
1960                 }
1961         }
1962
1963         manager_recheck_journal(m);
1964         unit_trigger_notify(u);
1965
1966         if (u->manager->n_reloading <= 0) {
1967                 /* Maybe we finished startup and are now ready for
1968                  * being stopped because unneeded? */
1969                 unit_check_unneeded(u);
1970
1971                 /* Maybe we finished startup, but something we needed
1972                  * has vanished? Let's die then. (This happens when
1973                  * something BindsTo= to a Type=oneshot unit, as these
1974                  * units go directly from starting to inactive,
1975                  * without ever entering started.) */
1976                 unit_check_binds_to(u);
1977         }
1978
1979         unit_add_to_dbus_queue(u);
1980         unit_add_to_gc_queue(u);
1981 }
1982
1983 int unit_watch_pid(Unit *u, pid_t pid) {
1984         int q, r;
1985
1986         assert(u);
1987         assert(pid >= 1);
1988
1989         /* Watch a specific PID. We only support one or two units
1990          * watching each PID for now, not more. */
1991
1992         r = set_ensure_allocated(&u->pids, NULL);
1993         if (r < 0)
1994                 return r;
1995
1996         r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
1997         if (r < 0)
1998                 return r;
1999
2000         r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
2001         if (r == -EEXIST) {
2002                 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
2003                 if (r < 0)
2004                         return r;
2005
2006                 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
2007         }
2008
2009         q = set_put(u->pids, LONG_TO_PTR(pid));
2010         if (q < 0)
2011                 return q;
2012
2013         return r;
2014 }
2015
2016 void unit_unwatch_pid(Unit *u, pid_t pid) {
2017         assert(u);
2018         assert(pid >= 1);
2019
2020         hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
2021         hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
2022         set_remove(u->pids, LONG_TO_PTR(pid));
2023 }
2024
2025 void unit_unwatch_all_pids(Unit *u) {
2026         assert(u);
2027
2028         while (!set_isempty(u->pids))
2029                 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
2030
2031         set_free(u->pids);
2032         u->pids = NULL;
2033 }
2034
2035 static int unit_watch_pids_in_path(Unit *u, const char *path) {
2036         _cleanup_closedir_ DIR *d = NULL;
2037         _cleanup_fclose_ FILE *f = NULL;
2038         int ret = 0, r;
2039
2040         assert(u);
2041         assert(path);
2042
2043         /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
2044
2045         r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
2046         if (r >= 0) {
2047                 pid_t pid;
2048
2049                 while ((r = cg_read_pid(f, &pid)) > 0) {
2050                         r = unit_watch_pid(u, pid);
2051                         if (r < 0 && ret >= 0)
2052                                 ret = r;
2053                 }
2054                 if (r < 0 && ret >= 0)
2055                         ret = r;
2056
2057         } else if (ret >= 0)
2058                 ret = r;
2059
2060         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
2061         if (r >= 0) {
2062                 char *fn;
2063
2064                 while ((r = cg_read_subgroup(d, &fn)) > 0) {
2065                         _cleanup_free_ char *p = NULL;
2066
2067                         p = strjoin(path, "/", fn, NULL);
2068                         free(fn);
2069
2070                         if (!p)
2071                                 return -ENOMEM;
2072
2073                         r = unit_watch_pids_in_path(u, p);
2074                         if (r < 0 && ret >= 0)
2075                                 ret = r;
2076                 }
2077                 if (r < 0 && ret >= 0)
2078                         ret = r;
2079
2080         } else if (ret >= 0)
2081                 ret = r;
2082
2083         return ret;
2084 }
2085
2086 int unit_watch_all_pids(Unit *u) {
2087         assert(u);
2088
2089         /* Adds all PIDs from our cgroup to the set of PIDs we watch */
2090
2091         if (!u->cgroup_path)
2092                 return -ENOENT;
2093
2094         return unit_watch_pids_in_path(u, u->cgroup_path);
2095 }
2096
2097 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
2098         Iterator i;
2099         void *e;
2100
2101         assert(u);
2102
2103         /* Cleans dead PIDs from our list */
2104
2105         SET_FOREACH(e, u->pids, i) {
2106                 pid_t pid = PTR_TO_LONG(e);
2107
2108                 if (pid == except1 || pid == except2)
2109                         continue;
2110
2111                 if (!pid_is_unwaited(pid))
2112                         unit_unwatch_pid(u, pid);
2113         }
2114 }
2115
2116 bool unit_job_is_applicable(Unit *u, JobType j) {
2117         assert(u);
2118         assert(j >= 0 && j < _JOB_TYPE_MAX);
2119
2120         switch (j) {
2121
2122         case JOB_VERIFY_ACTIVE:
2123         case JOB_START:
2124         case JOB_STOP:
2125         case JOB_NOP:
2126                 return true;
2127
2128         case JOB_RESTART:
2129         case JOB_TRY_RESTART:
2130                 return unit_can_start(u);
2131
2132         case JOB_RELOAD:
2133                 return unit_can_reload(u);
2134
2135         case JOB_RELOAD_OR_START:
2136                 return unit_can_reload(u) && unit_can_start(u);
2137
2138         default:
2139                 assert_not_reached("Invalid job type");
2140         }
2141 }
2142
2143 static int maybe_warn_about_dependency(const char *id, const char *other, UnitDependency dependency) {
2144         assert(id);
2145
2146         switch (dependency) {
2147         case UNIT_REQUIRES:
2148         case UNIT_REQUIRES_OVERRIDABLE:
2149         case UNIT_WANTS:
2150         case UNIT_REQUISITE:
2151         case UNIT_REQUISITE_OVERRIDABLE:
2152         case UNIT_BINDS_TO:
2153         case UNIT_PART_OF:
2154         case UNIT_REQUIRED_BY:
2155         case UNIT_REQUIRED_BY_OVERRIDABLE:
2156         case UNIT_WANTED_BY:
2157         case UNIT_BOUND_BY:
2158         case UNIT_CONSISTS_OF:
2159         case UNIT_REFERENCES:
2160         case UNIT_REFERENCED_BY:
2161         case UNIT_PROPAGATES_RELOAD_TO:
2162         case UNIT_RELOAD_PROPAGATED_FROM:
2163         case UNIT_JOINS_NAMESPACE_OF:
2164                 return 0;
2165
2166         case UNIT_CONFLICTS:
2167         case UNIT_CONFLICTED_BY:
2168         case UNIT_BEFORE:
2169         case UNIT_AFTER:
2170         case UNIT_ON_FAILURE:
2171         case UNIT_TRIGGERS:
2172         case UNIT_TRIGGERED_BY:
2173                 if (streq_ptr(id, other))
2174                         log_unit_warning(id, "Dependency %s=%s dropped from unit %s",
2175                                          unit_dependency_to_string(dependency), id, other);
2176                 else
2177                         log_unit_warning(id, "Dependency %s=%s dropped from unit %s merged into %s",
2178                                          unit_dependency_to_string(dependency), id,
2179                                          strna(other), id);
2180                 return -EINVAL;
2181
2182         case _UNIT_DEPENDENCY_MAX:
2183         case _UNIT_DEPENDENCY_INVALID:
2184                 break;
2185         }
2186
2187         assert_not_reached("Invalid dependency type");
2188 }
2189
2190 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2191
2192         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2193                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2194                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2195                 [UNIT_WANTS] = UNIT_WANTED_BY,
2196                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2197                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2198                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2199                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2200                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2201                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2202                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2203                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2204                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2205                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2206                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2207                 [UNIT_BEFORE] = UNIT_AFTER,
2208                 [UNIT_AFTER] = UNIT_BEFORE,
2209                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2210                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2211                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2212                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2213                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2214                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2215                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2216                 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2217         };
2218         int r, q = 0, v = 0, w = 0;
2219         Unit *orig_u = u, *orig_other = other;
2220
2221         assert(u);
2222         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2223         assert(other);
2224
2225         u = unit_follow_merge(u);
2226         other = unit_follow_merge(other);
2227
2228         /* We won't allow dependencies on ourselves. We will not
2229          * consider them an error however. */
2230         if (u == other) {
2231                 maybe_warn_about_dependency(orig_u->id, orig_other->id, d);
2232                 return 0;
2233         }
2234
2235         r = set_ensure_allocated(&u->dependencies[d], NULL);
2236         if (r < 0)
2237                 return r;
2238
2239         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2240                 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2241                 if (r < 0)
2242                         return r;
2243         }
2244
2245         if (add_reference) {
2246                 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2247                 if (r < 0)
2248                         return r;
2249
2250                 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2251                 if (r < 0)
2252                         return r;
2253         }
2254
2255         q = set_put(u->dependencies[d], other);
2256         if (q < 0)
2257                 return q;
2258
2259         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2260                 v = set_put(other->dependencies[inverse_table[d]], u);
2261                 if (v < 0) {
2262                         r = v;
2263                         goto fail;
2264                 }
2265         }
2266
2267         if (add_reference) {
2268                 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2269                 if (w < 0) {
2270                         r = w;
2271                         goto fail;
2272                 }
2273
2274                 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2275                 if (r < 0)
2276                         goto fail;
2277         }
2278
2279         unit_add_to_dbus_queue(u);
2280         return 0;
2281
2282 fail:
2283         if (q > 0)
2284                 set_remove(u->dependencies[d], other);
2285
2286         if (v > 0)
2287                 set_remove(other->dependencies[inverse_table[d]], u);
2288
2289         if (w > 0)
2290                 set_remove(u->dependencies[UNIT_REFERENCES], other);
2291
2292         return r;
2293 }
2294
2295 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2296         int r;
2297
2298         assert(u);
2299
2300         r = unit_add_dependency(u, d, other, add_reference);
2301         if (r < 0)
2302                 return r;
2303
2304         r = unit_add_dependency(u, e, other, add_reference);
2305         if (r < 0)
2306                 return r;
2307
2308         return 0;
2309 }
2310
2311 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2312         char *s;
2313
2314         assert(u);
2315         assert(name || path);
2316         assert(p);
2317
2318         if (!name)
2319                 name = basename(path);
2320
2321         if (!unit_name_is_template(name)) {
2322                 *p = NULL;
2323                 return name;
2324         }
2325
2326         if (u->instance)
2327                 s = unit_name_replace_instance(name, u->instance);
2328         else {
2329                 _cleanup_free_ char *i = NULL;
2330
2331                 i = unit_name_to_prefix(u->id);
2332                 if (!i)
2333                         return NULL;
2334
2335                 s = unit_name_replace_instance(name, i);
2336         }
2337
2338         if (!s)
2339                 return NULL;
2340
2341         *p = s;
2342         return s;
2343 }
2344
2345 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2346         Unit *other;
2347         int r;
2348         _cleanup_free_ char *s = NULL;
2349
2350         assert(u);
2351         assert(name || path);
2352
2353         name = resolve_template(u, name, path, &s);
2354         if (!name)
2355                 return -ENOMEM;
2356
2357         r = manager_load_unit(u->manager, name, path, NULL, &other);
2358         if (r < 0)
2359                 return r;
2360
2361         return unit_add_dependency(u, d, other, add_reference);
2362 }
2363
2364 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2365         _cleanup_free_ char *s = NULL;
2366         Unit *other;
2367         int r;
2368
2369         assert(u);
2370         assert(name || path);
2371
2372         name = resolve_template(u, name, path, &s);
2373         if (!name)
2374                 return -ENOMEM;
2375
2376         r = manager_load_unit(u->manager, name, path, NULL, &other);
2377         if (r < 0)
2378                 return r;
2379
2380         return unit_add_two_dependencies(u, d, e, other, add_reference);
2381 }
2382
2383 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2384         Unit *other;
2385         int r;
2386         _cleanup_free_ char *s = NULL;
2387
2388         assert(u);
2389         assert(name || path);
2390
2391         name = resolve_template(u, name, path, &s);
2392         if (!name)
2393                 return -ENOMEM;
2394
2395         r = manager_load_unit(u->manager, name, path, NULL, &other);
2396         if (r < 0)
2397                 return r;
2398
2399         return unit_add_dependency(other, d, u, add_reference);
2400 }
2401
2402 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2403         Unit *other;
2404         int r;
2405         _cleanup_free_ char *s = NULL;
2406
2407         assert(u);
2408         assert(name || path);
2409
2410         name = resolve_template(u, name, path, &s);
2411         if (!name)
2412                 return -ENOMEM;
2413
2414         r = manager_load_unit(u->manager, name, path, NULL, &other);
2415         if (r < 0)
2416                 return r;
2417
2418         r = unit_add_two_dependencies(other, d, e, u, add_reference);
2419         if (r < 0)
2420                 return r;
2421
2422         return r;
2423 }
2424
2425 int set_unit_path(const char *p) {
2426         /* This is mostly for debug purposes */
2427         if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2428                 return -errno;
2429
2430         return 0;
2431 }
2432
2433 char *unit_dbus_path(Unit *u) {
2434         assert(u);
2435
2436         if (!u->id)
2437                 return NULL;
2438
2439         return unit_dbus_path_from_name(u->id);
2440 }
2441
2442 char *unit_default_cgroup_path(Unit *u) {
2443         _cleanup_free_ char *escaped = NULL, *slice = NULL;
2444         int r;
2445
2446         assert(u);
2447
2448         if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2449                 return strdup(u->manager->cgroup_root);
2450
2451         if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2452                 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2453                 if (r < 0)
2454                         return NULL;
2455         }
2456
2457         escaped = cg_escape(u->id);
2458         if (!escaped)
2459                 return NULL;
2460
2461         if (slice)
2462                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2463         else
2464                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2465 }
2466
2467 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2468         _cleanup_free_ char *b = NULL;
2469         const char *slice_name;
2470         Unit *slice;
2471         int r;
2472
2473         assert(u);
2474         assert(c);
2475
2476         if (UNIT_ISSET(u->slice))
2477                 return 0;
2478
2479         if (u->instance) {
2480                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2481
2482                 /* Implicitly place all instantiated units in their
2483                  * own per-template slice */
2484
2485                 prefix = unit_name_to_prefix(u->id);
2486                 if (!prefix)
2487                         return -ENOMEM;
2488
2489                 /* The prefix is already escaped, but it might include
2490                  * "-" which has a special meaning for slice units,
2491                  * hence escape it here extra. */
2492                 escaped = strreplace(prefix, "-", "\\x2d");
2493                 if (!escaped)
2494                         return -ENOMEM;
2495
2496                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2497                         b = strjoin("system-", escaped, ".slice", NULL);
2498                 else
2499                         b = strappend(escaped, ".slice");
2500                 if (!b)
2501                         return -ENOMEM;
2502
2503                 slice_name = b;
2504         } else
2505                 slice_name =
2506                         u->manager->running_as == SYSTEMD_SYSTEM
2507                         ? SPECIAL_SYSTEM_SLICE
2508                         : SPECIAL_ROOT_SLICE;
2509
2510         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2511         if (r < 0)
2512                 return r;
2513
2514         unit_ref_set(&u->slice, slice);
2515         return 0;
2516 }
2517
2518 const char *unit_slice_name(Unit *u) {
2519         assert(u);
2520
2521         if (!UNIT_ISSET(u->slice))
2522                 return NULL;
2523
2524         return UNIT_DEREF(u->slice)->id;
2525 }
2526
2527 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2528         _cleanup_free_ char *t = NULL;
2529         int r;
2530
2531         assert(u);
2532         assert(type);
2533         assert(_found);
2534
2535         t = unit_name_change_suffix(u->id, type);
2536         if (!t)
2537                 return -ENOMEM;
2538
2539         assert(!unit_has_name(u, t));
2540
2541         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2542         assert(r < 0 || *_found != u);
2543         return r;
2544 }
2545
2546 int unit_watch_bus_name(Unit *u, const char *name) {
2547         assert(u);
2548         assert(name);
2549
2550         /* Watch a specific name on the bus. We only support one unit
2551          * watching each name for now. */
2552
2553         return hashmap_put(u->manager->watch_bus, name, u);
2554 }
2555
2556 void unit_unwatch_bus_name(Unit *u, const char *name) {
2557         assert(u);
2558         assert(name);
2559
2560         hashmap_remove_value(u->manager->watch_bus, name, u);
2561 }
2562
2563 bool unit_can_serialize(Unit *u) {
2564         assert(u);
2565
2566         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2567 }
2568
2569 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2570         int r;
2571
2572         assert(u);
2573         assert(f);
2574         assert(fds);
2575
2576         if (unit_can_serialize(u)) {
2577                 ExecRuntime *rt;
2578
2579                 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2580                 if (r < 0)
2581                         return r;
2582
2583                 rt = unit_get_exec_runtime(u);
2584                 if (rt) {
2585                         r = exec_runtime_serialize(rt, u, f, fds);
2586                         if (r < 0)
2587                                 return r;
2588                 }
2589         }
2590
2591         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2592         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2593         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2594         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2595         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2596         dual_timestamp_serialize(f, "assert-timestamp", &u->assert_timestamp);
2597
2598         if (dual_timestamp_is_set(&u->condition_timestamp))
2599                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2600
2601         if (dual_timestamp_is_set(&u->assert_timestamp))
2602                 unit_serialize_item(u, f, "assert-result", yes_no(u->assert_result));
2603
2604         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2605
2606         if (u->cgroup_path)
2607                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2608
2609         if (serialize_jobs) {
2610                 if (u->job) {
2611                         fprintf(f, "job\n");
2612                         job_serialize(u->job, f, fds);
2613                 }
2614
2615                 if (u->nop_job) {
2616                         fprintf(f, "job\n");
2617                         job_serialize(u->nop_job, f, fds);
2618                 }
2619         }
2620
2621         /* End marker */
2622         fputc('\n', f);
2623         return 0;
2624 }
2625
2626 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2627         va_list ap;
2628
2629         assert(u);
2630         assert(f);
2631         assert(key);
2632         assert(format);
2633
2634         fputs(key, f);
2635         fputc('=', f);
2636
2637         va_start(ap, format);
2638         vfprintf(f, format, ap);
2639         va_end(ap);
2640
2641         fputc('\n', f);
2642 }
2643
2644 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2645         assert(u);
2646         assert(f);
2647         assert(key);
2648         assert(value);
2649
2650         fprintf(f, "%s=%s\n", key, value);
2651 }
2652
2653 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2654         ExecRuntime **rt = NULL;
2655         size_t offset;
2656         int r;
2657
2658         assert(u);
2659         assert(f);
2660         assert(fds);
2661
2662         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2663         if (offset > 0)
2664                 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2665
2666         for (;;) {
2667                 char line[LINE_MAX], *l, *v;
2668                 size_t k;
2669
2670                 if (!fgets(line, sizeof(line), f)) {
2671                         if (feof(f))
2672                                 return 0;
2673                         return -errno;
2674                 }
2675
2676                 char_array_0(line);
2677                 l = strstrip(line);
2678
2679                 /* End marker */
2680                 if (l[0] == 0)
2681                         return 0;
2682
2683                 k = strcspn(l, "=");
2684
2685                 if (l[k] == '=') {
2686                         l[k] = 0;
2687                         v = l+k+1;
2688                 } else
2689                         v = l+k;
2690
2691                 if (streq(l, "job")) {
2692                         if (v[0] == '\0') {
2693                                 /* new-style serialized job */
2694                                 Job *j;
2695
2696                                 j = job_new_raw(u);
2697                                 if (!j)
2698                                         return -ENOMEM;
2699
2700                                 r = job_deserialize(j, f, fds);
2701                                 if (r < 0) {
2702                                         job_free(j);
2703                                         return r;
2704                                 }
2705
2706                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2707                                 if (r < 0) {
2708                                         job_free(j);
2709                                         return r;
2710                                 }
2711
2712                                 r = job_install_deserialized(j);
2713                                 if (r < 0) {
2714                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2715                                         job_free(j);
2716                                         return r;
2717                                 }
2718                         } else {
2719                                 /* legacy */
2720                                 JobType type;
2721
2722                                 type = job_type_from_string(v);
2723                                 if (type < 0)
2724                                         log_debug("Failed to parse job type value %s", v);
2725                                 else
2726                                         u->deserialized_job = type;
2727                         }
2728                         continue;
2729                 } else if (streq(l, "inactive-exit-timestamp")) {
2730                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2731                         continue;
2732                 } else if (streq(l, "active-enter-timestamp")) {
2733                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2734                         continue;
2735                 } else if (streq(l, "active-exit-timestamp")) {
2736                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2737                         continue;
2738                 } else if (streq(l, "inactive-enter-timestamp")) {
2739                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2740                         continue;
2741                 } else if (streq(l, "condition-timestamp")) {
2742                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2743                         continue;
2744                 } else if (streq(l, "assert-timestamp")) {
2745                         dual_timestamp_deserialize(v, &u->assert_timestamp);
2746                         continue;
2747                 } else if (streq(l, "condition-result")) {
2748                         int b;
2749
2750                         b = parse_boolean(v);
2751                         if (b < 0)
2752                                 log_debug("Failed to parse condition result value %s", v);
2753                         else
2754                                 u->condition_result = b;
2755
2756                         continue;
2757
2758                 } else if (streq(l, "assert-result")) {
2759                         int b;
2760
2761                         b = parse_boolean(v);
2762                         if (b < 0)
2763                                 log_debug("Failed to parse assert result value %s", v);
2764                         else
2765                                 u->assert_result = b;
2766
2767                         continue;
2768
2769                 } else if (streq(l, "transient")) {
2770                         int b;
2771
2772                         b = parse_boolean(v);
2773                         if (b < 0)
2774                                 log_debug("Failed to parse transient bool %s", v);
2775                         else
2776                                 u->transient = b;
2777
2778                         continue;
2779                 } else if (streq(l, "cgroup")) {
2780                         char *s;
2781
2782                         s = strdup(v);
2783                         if (!s)
2784                                 return -ENOMEM;
2785
2786                         if (u->cgroup_path) {
2787                                 void *p;
2788
2789                                 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2790                                 log_info("Removing cgroup_path %s from hashmap (%p)",
2791                                          u->cgroup_path, p);
2792                                 free(u->cgroup_path);
2793                         }
2794
2795                         u->cgroup_path = s;
2796                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2797
2798                         continue;
2799                 }
2800
2801                 if (unit_can_serialize(u)) {
2802                         if (rt) {
2803                                 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2804                                 if (r < 0)
2805                                         return r;
2806                                 if (r > 0)
2807                                         continue;
2808                         }
2809
2810                         r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2811                         if (r < 0)
2812                                 return r;
2813                 }
2814         }
2815 }
2816
2817 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2818         Unit *device;
2819         _cleanup_free_ char *e = NULL;
2820         int r;
2821
2822         assert(u);
2823
2824         if (!what)
2825                 return 0;
2826
2827         /* Adds in links to the device node that this unit is based on */
2828
2829         if (!is_device_path(what))
2830                 return 0;
2831
2832         e = unit_name_from_path(what, ".device");
2833         if (!e)
2834                 return -ENOMEM;
2835
2836         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2837         if (r < 0)
2838                 return r;
2839
2840         r = unit_add_two_dependencies(u, UNIT_AFTER, u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_BINDS_TO : UNIT_WANTS, device, true);
2841         if (r < 0)
2842                 return r;
2843
2844         if (wants) {
2845                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2846                 if (r < 0)
2847                         return r;
2848         }
2849
2850         return 0;
2851 }
2852
2853 int unit_coldplug(Unit *u) {
2854         int r;
2855
2856         assert(u);
2857
2858         if (UNIT_VTABLE(u)->coldplug)
2859                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2860                         return r;
2861
2862         if (u->job) {
2863                 r = job_coldplug(u->job);
2864                 if (r < 0)
2865                         return r;
2866         } else if (u->deserialized_job >= 0) {
2867                 /* legacy */
2868                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2869                 if (r < 0)
2870                         return r;
2871
2872                 u->deserialized_job = _JOB_TYPE_INVALID;
2873         }
2874
2875         return 0;
2876 }
2877
2878 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2879         DISABLE_WARNING_FORMAT_NONLITERAL;
2880         manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2881                               status, unit_status_msg_format, unit_description(u));
2882         REENABLE_WARNING;
2883 }
2884
2885 bool unit_need_daemon_reload(Unit *u) {
2886         _cleanup_strv_free_ char **t = NULL;
2887         char **path;
2888         struct stat st;
2889         unsigned loaded_cnt, current_cnt;
2890
2891         assert(u);
2892
2893         if (u->fragment_path) {
2894                 zero(st);
2895                 if (stat(u->fragment_path, &st) < 0)
2896                         /* What, cannot access this anymore? */
2897                         return true;
2898
2899                 if (u->fragment_mtime > 0 &&
2900                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2901                         return true;
2902         }
2903
2904         if (u->source_path) {
2905                 zero(st);
2906                 if (stat(u->source_path, &st) < 0)
2907                         return true;
2908
2909                 if (u->source_mtime > 0 &&
2910                     timespec_load(&st.st_mtim) != u->source_mtime)
2911                         return true;
2912         }
2913
2914         (void) unit_find_dropin_paths(u, &t);
2915         loaded_cnt = strv_length(t);
2916         current_cnt = strv_length(u->dropin_paths);
2917
2918         if (loaded_cnt == current_cnt) {
2919                 if (loaded_cnt == 0)
2920                         return false;
2921
2922                 if (strv_overlap(u->dropin_paths, t)) {
2923                         STRV_FOREACH(path, u->dropin_paths) {
2924                                 zero(st);
2925                                 if (stat(*path, &st) < 0)
2926                                         return true;
2927
2928                                 if (u->dropin_mtime > 0 &&
2929                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2930                                         return true;
2931                         }
2932
2933                         return false;
2934                 } else
2935                         return true;
2936         } else
2937                 return true;
2938 }
2939
2940 void unit_reset_failed(Unit *u) {
2941         assert(u);
2942
2943         if (UNIT_VTABLE(u)->reset_failed)
2944                 UNIT_VTABLE(u)->reset_failed(u);
2945 }
2946
2947 Unit *unit_following(Unit *u) {
2948         assert(u);
2949
2950         if (UNIT_VTABLE(u)->following)
2951                 return UNIT_VTABLE(u)->following(u);
2952
2953         return NULL;
2954 }
2955
2956 bool unit_stop_pending(Unit *u) {
2957         assert(u);
2958
2959         /* This call does check the current state of the unit. It's
2960          * hence useful to be called from state change calls of the
2961          * unit itself, where the state isn't updated yet. This is
2962          * different from unit_inactive_or_pending() which checks both
2963          * the current state and for a queued job. */
2964
2965         return u->job && u->job->type == JOB_STOP;
2966 }
2967
2968 bool unit_inactive_or_pending(Unit *u) {
2969         assert(u);
2970
2971         /* Returns true if the unit is inactive or going down */
2972
2973         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2974                 return true;
2975
2976         if (unit_stop_pending(u))
2977                 return true;
2978
2979         return false;
2980 }
2981
2982 bool unit_active_or_pending(Unit *u) {
2983         assert(u);
2984
2985         /* Returns true if the unit is active or going up */
2986
2987         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2988                 return true;
2989
2990         if (u->job &&
2991             (u->job->type == JOB_START ||
2992              u->job->type == JOB_RELOAD_OR_START ||
2993              u->job->type == JOB_RESTART))
2994                 return true;
2995
2996         return false;
2997 }
2998
2999 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
3000         assert(u);
3001         assert(w >= 0 && w < _KILL_WHO_MAX);
3002         assert(signo > 0);
3003         assert(signo < _NSIG);
3004
3005         if (!UNIT_VTABLE(u)->kill)
3006                 return -ENOTSUP;
3007
3008         return UNIT_VTABLE(u)->kill(u, w, signo, error);
3009 }
3010
3011 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
3012         Set *pid_set;
3013         int r;
3014
3015         pid_set = set_new(NULL);
3016         if (!pid_set)
3017                 return NULL;
3018
3019         /* Exclude the main/control pids from being killed via the cgroup */
3020         if (main_pid > 0) {
3021                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
3022                 if (r < 0)
3023                         goto fail;
3024         }
3025
3026         if (control_pid > 0) {
3027                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
3028                 if (r < 0)
3029                         goto fail;
3030         }
3031
3032         return pid_set;
3033
3034 fail:
3035         set_free(pid_set);
3036         return NULL;
3037 }
3038
3039 int unit_kill_common(
3040                 Unit *u,
3041                 KillWho who,
3042                 int signo,
3043                 pid_t main_pid,
3044                 pid_t control_pid,
3045                 sd_bus_error *error) {
3046
3047         int r = 0;
3048
3049         if (who == KILL_MAIN && main_pid <= 0) {
3050                 if (main_pid < 0)
3051                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
3052                 else
3053                         return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3054         }
3055
3056         if (who == KILL_CONTROL && control_pid <= 0) {
3057                 if (control_pid < 0)
3058                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
3059                 else
3060                         return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3061         }
3062
3063         if (who == KILL_CONTROL || who == KILL_ALL)
3064                 if (control_pid > 0)
3065                         if (kill(control_pid, signo) < 0)
3066                                 r = -errno;
3067
3068         if (who == KILL_MAIN || who == KILL_ALL)
3069                 if (main_pid > 0)
3070                         if (kill(main_pid, signo) < 0)
3071                                 r = -errno;
3072
3073         if (who == KILL_ALL && u->cgroup_path) {
3074                 _cleanup_set_free_ Set *pid_set = NULL;
3075                 int q;
3076
3077                 /* Exclude the main/control pids from being killed via the cgroup */
3078                 pid_set = unit_pid_set(main_pid, control_pid);
3079                 if (!pid_set)
3080                         return -ENOMEM;
3081
3082                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
3083                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3084                         r = q;
3085         }
3086
3087         return r;
3088 }
3089
3090 int unit_following_set(Unit *u, Set **s) {
3091         assert(u);
3092         assert(s);
3093
3094         if (UNIT_VTABLE(u)->following_set)
3095                 return UNIT_VTABLE(u)->following_set(u, s);
3096
3097         *s = NULL;
3098         return 0;
3099 }
3100
3101 UnitFileState unit_get_unit_file_state(Unit *u) {
3102         assert(u);
3103
3104         if (u->unit_file_state < 0 && u->fragment_path)
3105                 u->unit_file_state = unit_file_get_state(
3106                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3107                                 NULL, basename(u->fragment_path));
3108
3109         return u->unit_file_state;
3110 }
3111
3112 int unit_get_unit_file_preset(Unit *u) {
3113         assert(u);
3114
3115         if (u->unit_file_preset < 0 && u->fragment_path)
3116                 u->unit_file_preset = unit_file_query_preset(
3117                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3118                                 NULL, basename(u->fragment_path));
3119
3120         return u->unit_file_preset;
3121 }
3122
3123 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3124         assert(ref);
3125         assert(u);
3126
3127         if (ref->unit)
3128                 unit_ref_unset(ref);
3129
3130         ref->unit = u;
3131         LIST_PREPEND(refs, u->refs, ref);
3132         return u;
3133 }
3134
3135 void unit_ref_unset(UnitRef *ref) {
3136         assert(ref);
3137
3138         if (!ref->unit)
3139                 return;
3140
3141         LIST_REMOVE(refs, ref->unit->refs, ref);
3142         ref->unit = NULL;
3143 }
3144
3145 int unit_patch_contexts(Unit *u) {
3146         CGroupContext *cc;
3147         ExecContext *ec;
3148         unsigned i;
3149         int r;
3150
3151         assert(u);
3152
3153         /* Patch in the manager defaults into the exec and cgroup
3154          * contexts, _after_ the rest of the settings have been
3155          * initialized */
3156
3157         ec = unit_get_exec_context(u);
3158         if (ec) {
3159                 /* This only copies in the ones that need memory */
3160                 for (i = 0; i < _RLIMIT_MAX; i++)
3161                         if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3162                                 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3163                                 if (!ec->rlimit[i])
3164                                         return -ENOMEM;
3165                         }
3166
3167                 if (u->manager->running_as == SYSTEMD_USER &&
3168                     !ec->working_directory) {
3169
3170                         r = get_home_dir(&ec->working_directory);
3171                         if (r < 0)
3172                                 return r;
3173
3174                         /* Allow user services to run, even if the
3175                          * home directory is missing */
3176                         ec->working_directory_missing_ok = true;
3177                 }
3178
3179                 if (u->manager->running_as == SYSTEMD_USER &&
3180                     (ec->syscall_whitelist ||
3181                      !set_isempty(ec->syscall_filter) ||
3182                      !set_isempty(ec->syscall_archs) ||
3183                      ec->address_families_whitelist ||
3184                      !set_isempty(ec->address_families)))
3185                         ec->no_new_privileges = true;
3186
3187                 if (ec->private_devices)
3188                         ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3189         }
3190
3191         cc = unit_get_cgroup_context(u);
3192         if (cc) {
3193
3194                 if (ec &&
3195                     ec->private_devices &&
3196                     cc->device_policy == CGROUP_AUTO)
3197                         cc->device_policy = CGROUP_CLOSED;
3198         }
3199
3200         return 0;
3201 }
3202
3203 ExecContext *unit_get_exec_context(Unit *u) {
3204         size_t offset;
3205         assert(u);
3206
3207         if (u->type < 0)
3208                 return NULL;
3209
3210         offset = UNIT_VTABLE(u)->exec_context_offset;
3211         if (offset <= 0)
3212                 return NULL;
3213
3214         return (ExecContext*) ((uint8_t*) u + offset);
3215 }
3216
3217 KillContext *unit_get_kill_context(Unit *u) {
3218         size_t offset;
3219         assert(u);
3220
3221         if (u->type < 0)
3222                 return NULL;
3223
3224         offset = UNIT_VTABLE(u)->kill_context_offset;
3225         if (offset <= 0)
3226                 return NULL;
3227
3228         return (KillContext*) ((uint8_t*) u + offset);
3229 }
3230
3231 CGroupContext *unit_get_cgroup_context(Unit *u) {
3232         size_t offset;
3233
3234         if (u->type < 0)
3235                 return NULL;
3236
3237         offset = UNIT_VTABLE(u)->cgroup_context_offset;
3238         if (offset <= 0)
3239                 return NULL;
3240
3241         return (CGroupContext*) ((uint8_t*) u + offset);
3242 }
3243
3244 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3245         size_t offset;
3246
3247         if (u->type < 0)
3248                 return NULL;
3249
3250         offset = UNIT_VTABLE(u)->exec_runtime_offset;
3251         if (offset <= 0)
3252                 return NULL;
3253
3254         return *(ExecRuntime**) ((uint8_t*) u + offset);
3255 }
3256
3257 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3258         if (u->manager->running_as == SYSTEMD_USER) {
3259                 int r;
3260
3261                 if (mode == UNIT_PERSISTENT && !transient)
3262                         r = user_config_home(dir);
3263                 else
3264                         r = user_runtime_dir(dir);
3265
3266                 if (r == 0)
3267                         return -ENOENT;
3268                 return r;
3269         }
3270
3271         if (mode == UNIT_PERSISTENT && !transient)
3272                 *dir = strdup("/etc/systemd/system");
3273         else
3274                 *dir = strdup("/run/systemd/system");
3275         if (!*dir)
3276                 return -ENOMEM;
3277
3278         return 0;
3279 }
3280
3281 static int unit_drop_in_file(Unit *u,
3282                              UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3283         _cleanup_free_ char *dir = NULL;
3284         int r;
3285
3286         assert(u);
3287
3288         r = unit_drop_in_dir(u, mode, u->transient, &dir);
3289         if (r < 0)
3290                 return r;
3291
3292         return drop_in_file(dir, u->id, 50, name, p, q);
3293 }
3294
3295 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3296
3297         _cleanup_free_ char *dir = NULL, *p = NULL, *q = NULL;
3298         int r;
3299
3300         assert(u);
3301
3302         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3303                 return 0;
3304
3305         r = unit_drop_in_dir(u, mode, u->transient, &dir);
3306         if (r < 0)
3307                 return r;
3308
3309         r = write_drop_in(dir, u->id, 50, name, data);
3310         if (r < 0)
3311                 return r;
3312
3313         r = drop_in_file(dir, u->id, 50, name, &p, &q);
3314         if (r < 0)
3315                 return r;
3316
3317         r = strv_extend(&u->dropin_paths, q);
3318         if (r < 0)
3319                 return r;
3320
3321         strv_sort(u->dropin_paths);
3322         strv_uniq(u->dropin_paths);
3323
3324         u->dropin_mtime = now(CLOCK_REALTIME);
3325
3326         return 0;
3327 }
3328
3329 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3330         _cleanup_free_ char *p = NULL;
3331         va_list ap;
3332         int r;
3333
3334         assert(u);
3335         assert(name);
3336         assert(format);
3337
3338         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3339                 return 0;
3340
3341         va_start(ap, format);
3342         r = vasprintf(&p, format, ap);
3343         va_end(ap);
3344
3345         if (r < 0)
3346                 return -ENOMEM;
3347
3348         return unit_write_drop_in(u, mode, name, p);
3349 }
3350
3351 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3352         _cleanup_free_ char *ndata = NULL;
3353
3354         assert(u);
3355         assert(name);
3356         assert(data);
3357
3358         if (!UNIT_VTABLE(u)->private_section)
3359                 return -EINVAL;
3360
3361         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3362                 return 0;
3363
3364         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3365         if (!ndata)
3366                 return -ENOMEM;
3367
3368         return unit_write_drop_in(u, mode, name, ndata);
3369 }
3370
3371 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3372         _cleanup_free_ char *p = NULL;
3373         va_list ap;
3374         int r;
3375
3376         assert(u);
3377         assert(name);
3378         assert(format);
3379
3380         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3381                 return 0;
3382
3383         va_start(ap, format);
3384         r = vasprintf(&p, format, ap);
3385         va_end(ap);
3386
3387         if (r < 0)
3388                 return -ENOMEM;
3389
3390         return unit_write_drop_in_private(u, mode, name, p);
3391 }
3392
3393 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3394         _cleanup_free_ char *p = NULL, *q = NULL;
3395         int r;
3396
3397         assert(u);
3398
3399         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3400                 return 0;
3401
3402         r = unit_drop_in_file(u, mode, name, &p, &q);
3403         if (r < 0)
3404                 return r;
3405
3406         if (unlink(q) < 0)
3407                 r = errno == ENOENT ? 0 : -errno;
3408         else
3409                 r = 1;
3410
3411         rmdir(p);
3412         return r;
3413 }
3414
3415 int unit_make_transient(Unit *u) {
3416         int r;
3417
3418         assert(u);
3419
3420         u->load_state = UNIT_STUB;
3421         u->load_error = 0;
3422         u->transient = true;
3423
3424         free(u->fragment_path);
3425         u->fragment_path = NULL;
3426
3427         if (u->manager->running_as == SYSTEMD_USER) {
3428                 _cleanup_free_ char *c = NULL;
3429
3430                 r = user_runtime_dir(&c);
3431                 if (r < 0)
3432                         return r;
3433                 if (r == 0)
3434                         return -ENOENT;
3435
3436                 u->fragment_path = strjoin(c, "/", u->id, NULL);
3437                 if (!u->fragment_path)
3438                         return -ENOMEM;
3439
3440                 mkdir_p(c, 0755);
3441         } else {
3442                 u->fragment_path = strappend("/run/systemd/system/", u->id);
3443                 if (!u->fragment_path)
3444                         return -ENOMEM;
3445
3446                 mkdir_p("/run/systemd/system", 0755);
3447         }
3448
3449         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3450 }
3451
3452 int unit_kill_context(
3453                 Unit *u,
3454                 KillContext *c,
3455                 KillOperation k,
3456                 pid_t main_pid,
3457                 pid_t control_pid,
3458                 bool main_pid_alien) {
3459
3460         int sig, wait_for_exit = false, r;
3461
3462         assert(u);
3463         assert(c);
3464
3465         if (c->kill_mode == KILL_NONE)
3466                 return 0;
3467
3468         switch (k) {
3469         case KILL_KILL:
3470                 sig = SIGKILL;
3471                 break;
3472         case KILL_ABORT:
3473                 sig = SIGABRT;
3474                 break;
3475         case KILL_TERMINATE:
3476                 sig = c->kill_signal;
3477                 break;
3478         default:
3479                 assert_not_reached("KillOperation unknown");
3480         }
3481
3482         if (main_pid > 0) {
3483                 r = kill_and_sigcont(main_pid, sig);
3484
3485                 if (r < 0 && r != -ESRCH) {
3486                         _cleanup_free_ char *comm = NULL;
3487                         get_process_comm(main_pid, &comm);
3488
3489                         log_unit_warning_errno(u->id, r, "Failed to kill main process " PID_FMT " (%s): %m", main_pid, strna(comm));
3490                 } else {
3491                         if (!main_pid_alien)
3492                                 wait_for_exit = true;
3493
3494                         if (c->send_sighup && k != KILL_KILL)
3495                                 kill(main_pid, SIGHUP);
3496                 }
3497         }
3498
3499         if (control_pid > 0) {
3500                 r = kill_and_sigcont(control_pid, sig);
3501
3502                 if (r < 0 && r != -ESRCH) {
3503                         _cleanup_free_ char *comm = NULL;
3504                         get_process_comm(control_pid, &comm);
3505
3506                         log_unit_warning_errno(u->id, r, "Failed to kill control process " PID_FMT " (%s): %m", control_pid, strna(comm));
3507                 } else {
3508                         wait_for_exit = true;
3509
3510                         if (c->send_sighup && k != KILL_KILL)
3511                                 kill(control_pid, SIGHUP);
3512                 }
3513         }
3514
3515         if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL)) && u->cgroup_path) {
3516                 _cleanup_set_free_ Set *pid_set = NULL;
3517
3518                 /* Exclude the main/control pids from being killed via the cgroup */
3519                 pid_set = unit_pid_set(main_pid, control_pid);
3520                 if (!pid_set)
3521                         return -ENOMEM;
3522
3523                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3524                 if (r < 0) {
3525                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3526                                 log_unit_warning_errno(u->id, r, "Failed to kill control group: %m");
3527                 } else if (r > 0) {
3528
3529                         /* FIXME: For now, we will not wait for the
3530                          * cgroup members to die, simply because
3531                          * cgroup notification is unreliable. It
3532                          * doesn't work at all in containers, and
3533                          * outside of containers it can be confused
3534                          * easily by leaving directories in the
3535                          * cgroup. */
3536
3537                         /* wait_for_exit = true; */
3538
3539                         if (c->send_sighup && k != KILL_KILL) {
3540                                 set_free(pid_set);
3541
3542                                 pid_set = unit_pid_set(main_pid, control_pid);
3543                                 if (!pid_set)
3544                                         return -ENOMEM;
3545
3546                                 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3547                         }
3548                 }
3549         }
3550
3551         return wait_for_exit;
3552 }
3553
3554 int unit_require_mounts_for(Unit *u, const char *path) {
3555         char prefix[strlen(path) + 1], *p;
3556         int r;
3557
3558         assert(u);
3559         assert(path);
3560
3561         /* Registers a unit for requiring a certain path and all its
3562          * prefixes. We keep a simple array of these paths in the
3563          * unit, since its usually short. However, we build a prefix
3564          * table for all possible prefixes so that new appearing mount
3565          * units can easily determine which units to make themselves a
3566          * dependency of. */
3567
3568         if (!path_is_absolute(path))
3569                 return -EINVAL;
3570
3571         p = strdup(path);
3572         if (!p)
3573                 return -ENOMEM;
3574
3575         path_kill_slashes(p);
3576
3577         if (!path_is_safe(p)) {
3578                 free(p);
3579                 return -EPERM;
3580         }
3581
3582         if (strv_contains(u->requires_mounts_for, p)) {
3583                 free(p);
3584                 return 0;
3585         }
3586
3587         r = strv_consume(&u->requires_mounts_for, p);
3588         if (r < 0)
3589                 return r;
3590
3591         PATH_FOREACH_PREFIX_MORE(prefix, p) {
3592                 Set *x;
3593
3594                 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3595                 if (!x) {
3596                         char *q;
3597
3598                         if (!u->manager->units_requiring_mounts_for) {
3599                                 u->manager->units_requiring_mounts_for = hashmap_new(&string_hash_ops);
3600                                 if (!u->manager->units_requiring_mounts_for)
3601                                         return -ENOMEM;
3602                         }
3603
3604                         q = strdup(prefix);
3605                         if (!q)
3606                                 return -ENOMEM;
3607
3608                         x = set_new(NULL);
3609                         if (!x) {
3610                                 free(q);
3611                                 return -ENOMEM;
3612                         }
3613
3614                         r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3615                         if (r < 0) {
3616                                 free(q);
3617                                 set_free(x);
3618                                 return r;
3619                         }
3620                 }
3621
3622                 r = set_put(x, u);
3623                 if (r < 0)
3624                         return r;
3625         }
3626
3627         return 0;
3628 }
3629
3630 int unit_setup_exec_runtime(Unit *u) {
3631         ExecRuntime **rt;
3632         size_t offset;
3633         Iterator i;
3634         Unit *other;
3635
3636         offset = UNIT_VTABLE(u)->exec_runtime_offset;
3637         assert(offset > 0);
3638
3639         /* Check if there already is an ExecRuntime for this unit? */
3640         rt = (ExecRuntime**) ((uint8_t*) u + offset);
3641         if (*rt)
3642                 return 0;
3643
3644         /* Try to get it from somebody else */
3645         SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3646
3647                 *rt = unit_get_exec_runtime(other);
3648                 if (*rt) {
3649                         exec_runtime_ref(*rt);
3650                         return 0;
3651                 }
3652         }
3653
3654         return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3655 }
3656
3657 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3658         [UNIT_ACTIVE] = "active",
3659         [UNIT_RELOADING] = "reloading",
3660         [UNIT_INACTIVE] = "inactive",
3661         [UNIT_FAILED] = "failed",
3662         [UNIT_ACTIVATING] = "activating",
3663         [UNIT_DEACTIVATING] = "deactivating"
3664 };
3665
3666 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);