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