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