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