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