src/core/unit.c

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