src/core/unit.c

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