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