src/core/unit.c

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