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
  55 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
  56         [UNIT_SERVICE] = &service_vtable,
  57         [UNIT_SOCKET] = &socket_vtable,
  58         [UNIT_BUSNAME] = &busname_vtable,
  59         [UNIT_TARGET] = &target_vtable,
  60         [UNIT_SNAPSHOT] = &snapshot_vtable,
  61         [UNIT_DEVICE] = &device_vtable,
  62         [UNIT_MOUNT] = &mount_vtable,
  63         [UNIT_AUTOMOUNT] = &automount_vtable,
  64         [UNIT_SWAP] = &swap_vtable,
  65         [UNIT_TIMER] = &timer_vtable,
  66         [UNIT_PATH] = &path_vtable,
  67         [UNIT_SLICE] = &slice_vtable,
  68         [UNIT_SCOPE] = &scope_vtable
  69 };
  70
  71 Unit *unit_new(Manager *m, size_t size) {
  72         Unit *u;
  73
  74         assert(m);
  75         assert(size >= sizeof(Unit));
  76
  77         u = malloc0(size);
  78         if (!u)
  79                 return NULL;
  80
  81         u->names = set_new(string_hash_func, string_compare_func);
  82         if (!u->names) {
  83                 free(u);
  84                 return NULL;
  85         }
  86
  87         u->manager = m;
  88         u->type = _UNIT_TYPE_INVALID;
  89         u->deserialized_job = _JOB_TYPE_INVALID;
  90         u->default_dependencies = true;
  91         u->unit_file_state = _UNIT_FILE_STATE_INVALID;
  92         u->on_failure_job_mode = JOB_REPLACE;
  93
  94         return u;
  95 }
  96
  97 bool unit_has_name(Unit *u, const char *name) {
  98         assert(u);
  99         assert(name);
 100
 101         return !!set_get(u->names, (char*) name);
 102 }
 103
 104 static void unit_init(Unit *u) {
 105         CGroupContext *cc;
 106         ExecContext *ec;
 107         KillContext *kc;
 108
 109         assert(u);
 110         assert(u->manager);
 111         assert(u->type >= 0);
 112
 113         cc = unit_get_cgroup_context(u);
 114         if (cc) {
 115                 cgroup_context_init(cc);
 116
 117                 /* Copy in the manager defaults into the cgroup
 118                  * context, _before_ the rest of the settings have
 119                  * been initialized */
 120
 121                 cc->cpu_accounting = u->manager->default_cpu_accounting;
 122                 cc->blockio_accounting = u->manager->default_blockio_accounting;
 123                 cc->memory_accounting = u->manager->default_memory_accounting;
 124                 cc->cpu_quota_period_usec = u->manager->default_cpu_quota_period_usec;
 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 OK 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 of 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 just might have 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         _cleanup_free_ char *c = NULL;
2169
2170         /* This is mostly for debug purposes */
2171         c = path_make_absolute_cwd(p);
2172         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2173                 return -errno;
2174
2175         return 0;
2176 }
2177
2178 char *unit_dbus_path(Unit *u) {
2179         assert(u);
2180
2181         if (!u->id)
2182                 return NULL;
2183
2184         return unit_dbus_path_from_name(u->id);
2185 }
2186
2187 char *unit_default_cgroup_path(Unit *u) {
2188         _cleanup_free_ char *escaped = NULL, *slice = NULL;
2189         int r;
2190
2191         assert(u);
2192
2193         if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2194                 return strdup(u->manager->cgroup_root);
2195
2196         if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2197                 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2198                 if (r < 0)
2199                         return NULL;
2200         }
2201
2202         escaped = cg_escape(u->id);
2203         if (!escaped)
2204                 return NULL;
2205
2206         if (slice)
2207                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2208         else
2209                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2210 }
2211
2212 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2213         _cleanup_free_ char *b = NULL;
2214         const char *slice_name;
2215         Unit *slice;
2216         int r;
2217
2218         assert(u);
2219         assert(c);
2220
2221         if (UNIT_ISSET(u->slice))
2222                 return 0;
2223
2224         if (u->instance) {
2225                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2226
2227                 /* Implicitly place all instantiated units in their
2228                  * own per-template slice */
2229
2230                 prefix = unit_name_to_prefix(u->id);
2231                 if (!prefix)
2232                         return -ENOMEM;
2233
2234                 /* The prefix is already escaped, but it might include
2235                  * "-" which has a special meaning for slice units,
2236                  * hence escape it here extra. */
2237                 escaped = strreplace(prefix, "-", "\\x2d");
2238                 if (!escaped)
2239                         return -ENOMEM;
2240
2241                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2242                         b = strjoin("system-", escaped, ".slice", NULL);
2243                 else
2244                         b = strappend(escaped, ".slice");
2245                 if (!b)
2246                         return -ENOMEM;
2247
2248                 slice_name = b;
2249         } else
2250                 slice_name =
2251                         u->manager->running_as == SYSTEMD_SYSTEM
2252                         ? SPECIAL_SYSTEM_SLICE
2253                         : SPECIAL_ROOT_SLICE;
2254
2255         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2256         if (r < 0)
2257                 return r;
2258
2259         unit_ref_set(&u->slice, slice);
2260         return 0;
2261 }
2262
2263 const char *unit_slice_name(Unit *u) {
2264         assert(u);
2265
2266         if (!UNIT_ISSET(u->slice))
2267                 return NULL;
2268
2269         return UNIT_DEREF(u->slice)->id;
2270 }
2271
2272 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2273         _cleanup_free_ char *t = NULL;
2274         int r;
2275
2276         assert(u);
2277         assert(type);
2278         assert(_found);
2279
2280         t = unit_name_change_suffix(u->id, type);
2281         if (!t)
2282                 return -ENOMEM;
2283
2284         assert(!unit_has_name(u, t));
2285
2286         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2287         assert(r < 0 || *_found != u);
2288         return r;
2289 }
2290
2291 int unit_watch_bus_name(Unit *u, const char *name) {
2292         assert(u);
2293         assert(name);
2294
2295         /* Watch a specific name on the bus. We only support one unit
2296          * watching each name for now. */
2297
2298         return hashmap_put(u->manager->watch_bus, name, u);
2299 }
2300
2301 void unit_unwatch_bus_name(Unit *u, const char *name) {
2302         assert(u);
2303         assert(name);
2304
2305         hashmap_remove_value(u->manager->watch_bus, name, u);
2306 }
2307
2308 bool unit_can_serialize(Unit *u) {
2309         assert(u);
2310
2311         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2312 }
2313
2314 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2315         int r;
2316
2317         assert(u);
2318         assert(f);
2319         assert(fds);
2320
2321         if (unit_can_serialize(u)) {
2322                 ExecRuntime *rt;
2323
2324                 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2325                 if (r < 0)
2326                         return r;
2327
2328                 rt = unit_get_exec_runtime(u);
2329                 if (rt) {
2330                         r = exec_runtime_serialize(rt, u, f, fds);
2331                         if (r < 0)
2332                                 return r;
2333                 }
2334         }
2335
2336         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2337         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2338         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2339         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2340         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2341
2342         if (dual_timestamp_is_set(&u->condition_timestamp))
2343                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2344
2345         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2346
2347         if (u->cgroup_path)
2348                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2349
2350         if (serialize_jobs) {
2351                 if (u->job) {
2352                         fprintf(f, "job\n");
2353                         job_serialize(u->job, f, fds);
2354                 }
2355
2356                 if (u->nop_job) {
2357                         fprintf(f, "job\n");
2358                         job_serialize(u->nop_job, f, fds);
2359                 }
2360         }
2361
2362         /* End marker */
2363         fputc('\n', f);
2364         return 0;
2365 }
2366
2367 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2368         va_list ap;
2369
2370         assert(u);
2371         assert(f);
2372         assert(key);
2373         assert(format);
2374
2375         fputs(key, f);
2376         fputc('=', f);
2377
2378         va_start(ap, format);
2379         vfprintf(f, format, ap);
2380         va_end(ap);
2381
2382         fputc('\n', f);
2383 }
2384
2385 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2386         assert(u);
2387         assert(f);
2388         assert(key);
2389         assert(value);
2390
2391         fprintf(f, "%s=%s\n", key, value);
2392 }
2393
2394 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2395         ExecRuntime **rt = NULL;
2396         size_t offset;
2397         int r;
2398
2399         assert(u);
2400         assert(f);
2401         assert(fds);
2402
2403         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2404         if (offset > 0)
2405                 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2406
2407         for (;;) {
2408                 char line[LINE_MAX], *l, *v;
2409                 size_t k;
2410
2411                 if (!fgets(line, sizeof(line), f)) {
2412                         if (feof(f))
2413                                 return 0;
2414                         return -errno;
2415                 }
2416
2417                 char_array_0(line);
2418                 l = strstrip(line);
2419
2420                 /* End marker */
2421                 if (l[0] == 0)
2422                         return 0;
2423
2424                 k = strcspn(l, "=");
2425
2426                 if (l[k] == '=') {
2427                         l[k] = 0;
2428                         v = l+k+1;
2429                 } else
2430                         v = l+k;
2431
2432                 if (streq(l, "job")) {
2433                         if (v[0] == '\0') {
2434                                 /* new-style serialized job */
2435                                 Job *j = job_new_raw(u);
2436                                 if (!j)
2437                                         return -ENOMEM;
2438
2439                                 r = job_deserialize(j, f, fds);
2440                                 if (r < 0) {
2441                                         job_free(j);
2442                                         return r;
2443                                 }
2444
2445                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2446                                 if (r < 0) {
2447                                         job_free(j);
2448                                         return r;
2449                                 }
2450
2451                                 r = job_install_deserialized(j);
2452                                 if (r < 0) {
2453                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2454                                         job_free(j);
2455                                         return r;
2456                                 }
2457
2458                                 if (j->state == JOB_RUNNING)
2459                                         u->manager->n_running_jobs++;
2460                         } else {
2461                                 /* legacy */
2462                                 JobType type = job_type_from_string(v);
2463                                 if (type < 0)
2464                                         log_debug("Failed to parse job type value %s", v);
2465                                 else
2466                                         u->deserialized_job = type;
2467                         }
2468                         continue;
2469                 } else if (streq(l, "inactive-exit-timestamp")) {
2470                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2471                         continue;
2472                 } else if (streq(l, "active-enter-timestamp")) {
2473                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2474                         continue;
2475                 } else if (streq(l, "active-exit-timestamp")) {
2476                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2477                         continue;
2478                 } else if (streq(l, "inactive-enter-timestamp")) {
2479                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2480                         continue;
2481                 } else if (streq(l, "condition-timestamp")) {
2482                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2483                         continue;
2484                 } else if (streq(l, "condition-result")) {
2485                         int b;
2486
2487                         b = parse_boolean(v);
2488                         if (b < 0)
2489                                 log_debug("Failed to parse condition result value %s", v);
2490                         else
2491                                 u->condition_result = b;
2492
2493                         continue;
2494
2495                 } else if (streq(l, "transient")) {
2496                         int b;
2497
2498                         b = parse_boolean(v);
2499                         if (b < 0)
2500                                 log_debug("Failed to parse transient bool %s", v);
2501                         else
2502                                 u->transient = b;
2503
2504                         continue;
2505                 } else if (streq(l, "cgroup")) {
2506                         char *s;
2507
2508                         s = strdup(v);
2509                         if (!s)
2510                                 return -ENOMEM;
2511
2512                         if (u->cgroup_path) {
2513                                 void *p;
2514
2515                                 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2516                                 log_info("Removing cgroup_path %s from hashmap (%p)",
2517                                          u->cgroup_path, p);
2518                                 free(u->cgroup_path);
2519                         }
2520
2521                         u->cgroup_path = s;
2522                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2523
2524                         continue;
2525                 }
2526
2527                 if (unit_can_serialize(u)) {
2528                         if (rt) {
2529                                 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2530                                 if (r < 0)
2531                                         return r;
2532                                 if (r > 0)
2533                                         continue;
2534                         }
2535
2536                         r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2537                         if (r < 0)
2538                                 return r;
2539                 }
2540         }
2541 }
2542
2543 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2544         Unit *device;
2545         _cleanup_free_ char *e = NULL;
2546         int r;
2547
2548         assert(u);
2549
2550         if (!what)
2551                 return 0;
2552
2553         /* Adds in links to the device node that this unit is based on */
2554
2555         if (!is_device_path(what))
2556                 return 0;
2557
2558         e = unit_name_from_path(what, ".device");
2559         if (!e)
2560                 return -ENOMEM;
2561
2562         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2563
2564         if (r < 0)
2565                 return r;
2566
2567         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2568         if (r < 0)
2569                 return r;
2570
2571         if (wants) {
2572                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2573                 if (r < 0)
2574                         return r;
2575         }
2576
2577         return 0;
2578 }
2579
2580 int unit_coldplug(Unit *u) {
2581         int r;
2582
2583         assert(u);
2584
2585         if (UNIT_VTABLE(u)->coldplug)
2586                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2587                         return r;
2588
2589         if (u->job) {
2590                 r = job_coldplug(u->job);
2591                 if (r < 0)
2592                         return r;
2593         } else if (u->deserialized_job >= 0) {
2594                 /* legacy */
2595                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2596                 if (r < 0)
2597                         return r;
2598
2599                 u->deserialized_job = _JOB_TYPE_INVALID;
2600         }
2601
2602         return 0;
2603 }
2604
2605 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2606         DISABLE_WARNING_FORMAT_NONLITERAL;
2607         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2608         REENABLE_WARNING;
2609 }
2610
2611 bool unit_need_daemon_reload(Unit *u) {
2612         _cleanup_strv_free_ char **t = NULL;
2613         char **path;
2614         struct stat st;
2615         unsigned loaded_cnt, current_cnt;
2616
2617         assert(u);
2618
2619         if (u->fragment_path) {
2620                 zero(st);
2621                 if (stat(u->fragment_path, &st) < 0)
2622                         /* What, cannot access this anymore? */
2623                         return true;
2624
2625                 if (u->fragment_mtime > 0 &&
2626                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2627                         return true;
2628         }
2629
2630         if (u->source_path) {
2631                 zero(st);
2632                 if (stat(u->source_path, &st) < 0)
2633                         return true;
2634
2635                 if (u->source_mtime > 0 &&
2636                     timespec_load(&st.st_mtim) != u->source_mtime)
2637                         return true;
2638         }
2639
2640         t = unit_find_dropin_paths(u);
2641         loaded_cnt = strv_length(t);
2642         current_cnt = strv_length(u->dropin_paths);
2643
2644         if (loaded_cnt == current_cnt) {
2645                 if (loaded_cnt == 0)
2646                         return false;
2647
2648                 if (strv_overlap(u->dropin_paths, t)) {
2649                         STRV_FOREACH(path, u->dropin_paths) {
2650                                 zero(st);
2651                                 if (stat(*path, &st) < 0)
2652                                         return true;
2653
2654                                 if (u->dropin_mtime > 0 &&
2655                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2656                                         return true;
2657                         }
2658
2659                         return false;
2660                 } else
2661                         return true;
2662         } else
2663                 return true;
2664 }
2665
2666 void unit_reset_failed(Unit *u) {
2667         assert(u);
2668
2669         if (UNIT_VTABLE(u)->reset_failed)
2670                 UNIT_VTABLE(u)->reset_failed(u);
2671 }
2672
2673 Unit *unit_following(Unit *u) {
2674         assert(u);
2675
2676         if (UNIT_VTABLE(u)->following)
2677                 return UNIT_VTABLE(u)->following(u);
2678
2679         return NULL;
2680 }
2681
2682 bool unit_stop_pending(Unit *u) {
2683         assert(u);
2684
2685         /* This call does check the current state of the unit. It's
2686          * hence useful to be called from state change calls of the
2687          * unit itself, where the state isn't updated yet. This is
2688          * different from unit_inactive_or_pending() which checks both
2689          * the current state and for a queued job. */
2690
2691         return u->job && u->job->type == JOB_STOP;
2692 }
2693
2694 bool unit_inactive_or_pending(Unit *u) {
2695         assert(u);
2696
2697         /* Returns true if the unit is inactive or going down */
2698
2699         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2700                 return true;
2701
2702         if (unit_stop_pending(u))
2703                 return true;
2704
2705         return false;
2706 }
2707
2708 bool unit_active_or_pending(Unit *u) {
2709         assert(u);
2710
2711         /* Returns true if the unit is active or going up */
2712
2713         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2714                 return true;
2715
2716         if (u->job &&
2717             (u->job->type == JOB_START ||
2718              u->job->type == JOB_RELOAD_OR_START ||
2719              u->job->type == JOB_RESTART))
2720                 return true;
2721
2722         return false;
2723 }
2724
2725 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2726         assert(u);
2727         assert(w >= 0 && w < _KILL_WHO_MAX);
2728         assert(signo > 0);
2729         assert(signo < _NSIG);
2730
2731         if (!UNIT_VTABLE(u)->kill)
2732                 return -ENOTSUP;
2733
2734         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2735 }
2736
2737 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2738         Set *pid_set;
2739         int r;
2740
2741         pid_set = set_new(trivial_hash_func, trivial_compare_func);
2742         if (!pid_set)
2743                 return NULL;
2744
2745         /* Exclude the main/control pids from being killed via the cgroup */
2746         if (main_pid > 0) {
2747                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2748                 if (r < 0)
2749                         goto fail;
2750         }
2751
2752         if (control_pid > 0) {
2753                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2754                 if (r < 0)
2755                         goto fail;
2756         }
2757
2758         return pid_set;
2759
2760 fail:
2761         set_free(pid_set);
2762         return NULL;
2763 }
2764
2765 int unit_kill_common(
2766                 Unit *u,
2767                 KillWho who,
2768                 int signo,
2769                 pid_t main_pid,
2770                 pid_t control_pid,
2771                 sd_bus_error *error) {
2772
2773         int r = 0;
2774
2775         if (who == KILL_MAIN && main_pid <= 0) {
2776                 if (main_pid < 0)
2777                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2778                 else
2779                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2780                 return -ESRCH;
2781         }
2782
2783         if (who == KILL_CONTROL && control_pid <= 0) {
2784                 if (control_pid < 0)
2785                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2786                 else
2787                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2788                 return -ESRCH;
2789         }
2790
2791         if (who == KILL_CONTROL || who == KILL_ALL)
2792                 if (control_pid > 0)
2793                         if (kill(control_pid, signo) < 0)
2794                                 r = -errno;
2795
2796         if (who == KILL_MAIN || who == KILL_ALL)
2797                 if (main_pid > 0)
2798                         if (kill(main_pid, signo) < 0)
2799                                 r = -errno;
2800
2801         if (who == KILL_ALL && u->cgroup_path) {
2802                 _cleanup_set_free_ Set *pid_set = NULL;
2803                 int q;
2804
2805                 /* Exclude the main/control pids from being killed via the cgroup */
2806                 pid_set = unit_pid_set(main_pid, control_pid);
2807                 if (!pid_set)
2808                         return -ENOMEM;
2809
2810                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2811                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2812                         r = q;
2813         }
2814
2815         return r;
2816 }
2817
2818 int unit_following_set(Unit *u, Set **s) {
2819         assert(u);
2820         assert(s);
2821
2822         if (UNIT_VTABLE(u)->following_set)
2823                 return UNIT_VTABLE(u)->following_set(u, s);
2824
2825         *s = NULL;
2826         return 0;
2827 }
2828
2829 UnitFileState unit_get_unit_file_state(Unit *u) {
2830         assert(u);
2831
2832         if (u->unit_file_state < 0 && u->fragment_path)
2833                 u->unit_file_state = unit_file_get_state(
2834                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2835                                 NULL, basename(u->fragment_path));
2836
2837         return u->unit_file_state;
2838 }
2839
2840 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2841         assert(ref);
2842         assert(u);
2843
2844         if (ref->unit)
2845                 unit_ref_unset(ref);
2846
2847         ref->unit = u;
2848         LIST_PREPEND(refs, u->refs, ref);
2849         return u;
2850 }
2851
2852 void unit_ref_unset(UnitRef *ref) {
2853         assert(ref);
2854
2855         if (!ref->unit)
2856                 return;
2857
2858         LIST_REMOVE(refs, ref->unit->refs, ref);
2859         ref->unit = NULL;
2860 }
2861
2862 int unit_patch_contexts(Unit *u) {
2863         CGroupContext *cc;
2864         ExecContext *ec;
2865         unsigned i;
2866         int r;
2867
2868         assert(u);
2869
2870         /* Patch in the manager defaults into the exec and cgroup
2871          * contexts, _after_ the rest of the settings have been
2872          * initialized */
2873
2874         ec = unit_get_exec_context(u);
2875         if (ec) {
2876                 /* This only copies in the ones that need memory */
2877                 for (i = 0; i < _RLIMIT_MAX; i++)
2878                         if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2879                                 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2880                                 if (!ec->rlimit[i])
2881                                         return -ENOMEM;
2882                         }
2883
2884                 if (u->manager->running_as == SYSTEMD_USER &&
2885                     !ec->working_directory) {
2886
2887                         r = get_home_dir(&ec->working_directory);
2888                         if (r < 0)
2889                                 return r;
2890                 }
2891
2892                 if (u->manager->running_as == SYSTEMD_USER &&
2893                     (ec->syscall_whitelist ||
2894                      !set_isempty(ec->syscall_filter) ||
2895                      !set_isempty(ec->syscall_archs) ||
2896                      ec->address_families_whitelist ||
2897                      !set_isempty(ec->address_families)))
2898                         ec->no_new_privileges = true;
2899
2900                 if (ec->private_devices)
2901                         ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2902         }
2903
2904         cc = unit_get_cgroup_context(u);
2905         if (cc) {
2906
2907                 if (ec &&
2908                     ec->private_devices &&
2909                     cc->device_policy == CGROUP_AUTO)
2910                         cc->device_policy = CGROUP_CLOSED;
2911         }
2912
2913         return 0;
2914 }
2915
2916 ExecContext *unit_get_exec_context(Unit *u) {
2917         size_t offset;
2918         assert(u);
2919
2920         if (u->type < 0)
2921                 return NULL;
2922
2923         offset = UNIT_VTABLE(u)->exec_context_offset;
2924         if (offset <= 0)
2925                 return NULL;
2926
2927         return (ExecContext*) ((uint8_t*) u + offset);
2928 }
2929
2930 KillContext *unit_get_kill_context(Unit *u) {
2931         size_t offset;
2932         assert(u);
2933
2934         if (u->type < 0)
2935                 return NULL;
2936
2937         offset = UNIT_VTABLE(u)->kill_context_offset;
2938         if (offset <= 0)
2939                 return NULL;
2940
2941         return (KillContext*) ((uint8_t*) u + offset);
2942 }
2943
2944 CGroupContext *unit_get_cgroup_context(Unit *u) {
2945         size_t offset;
2946
2947         if (u->type < 0)
2948                 return NULL;
2949
2950         offset = UNIT_VTABLE(u)->cgroup_context_offset;
2951         if (offset <= 0)
2952                 return NULL;
2953
2954         return (CGroupContext*) ((uint8_t*) u + offset);
2955 }
2956
2957 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2958         size_t offset;
2959
2960         if (u->type < 0)
2961                 return NULL;
2962
2963         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2964         if (offset <= 0)
2965                 return NULL;
2966
2967         return *(ExecRuntime**) ((uint8_t*) u + offset);
2968 }
2969
2970 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2971         _cleanup_free_ char *b = NULL;
2972         char *p, *q;
2973         int r;
2974
2975         assert(u);
2976         assert(name);
2977         assert(_p);
2978         assert(_q);
2979
2980         b = xescape(name, "/.");
2981         if (!b)
2982                 return -ENOMEM;
2983
2984         if (!filename_is_safe(b))
2985                 return -EINVAL;
2986
2987         if (u->manager->running_as == SYSTEMD_USER) {
2988                 _cleanup_free_ char *c = NULL;
2989
2990                 r = user_config_home(&c);
2991                 if (r < 0)
2992                         return r;
2993                 if (r == 0)
2994                         return -ENOENT;
2995
2996                 p = strjoin(c, "/", u->id, ".d", NULL);
2997         } else if (mode == UNIT_PERSISTENT && !u->transient)
2998                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2999         else
3000                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
3001         if (!p)
3002                 return -ENOMEM;
3003
3004         q = strjoin(p, "/90-", b, ".conf", NULL);
3005         if (!q) {
3006                 free(p);
3007                 return -ENOMEM;
3008         }
3009
3010         *_p = p;
3011         *_q = q;
3012         return 0;
3013 }
3014
3015 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3016         _cleanup_free_ char *p = NULL, *q = NULL;
3017         int r;
3018
3019         assert(u);
3020         assert(name);
3021         assert(data);
3022
3023         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3024                 return 0;
3025
3026         r = drop_in_file(u, mode, name, &p, &q);
3027         if (r < 0)
3028                 return r;
3029
3030         mkdir_p(p, 0755);
3031         return write_string_file_atomic_label(q, data);
3032 }
3033
3034 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3035         _cleanup_free_ char *p = NULL;
3036         va_list ap;
3037         int r;
3038
3039         assert(u);
3040         assert(name);
3041         assert(format);
3042
3043         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3044                 return 0;
3045
3046         va_start(ap, format);
3047         r = vasprintf(&p, format, ap);
3048         va_end(ap);
3049
3050         if (r < 0)
3051                 return -ENOMEM;
3052
3053         return unit_write_drop_in(u, mode, name, p);
3054 }
3055
3056 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3057         _cleanup_free_ char *ndata = NULL;
3058
3059         assert(u);
3060         assert(name);
3061         assert(data);
3062
3063         if (!UNIT_VTABLE(u)->private_section)
3064                 return -EINVAL;
3065
3066         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3067                 return 0;
3068
3069         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3070         if (!ndata)
3071                 return -ENOMEM;
3072
3073         return unit_write_drop_in(u, mode, name, ndata);
3074 }
3075
3076 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3077         _cleanup_free_ char *p = NULL;
3078         va_list ap;
3079         int r;
3080
3081         assert(u);
3082         assert(name);
3083         assert(format);
3084
3085         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3086                 return 0;
3087
3088         va_start(ap, format);
3089         r = vasprintf(&p, format, ap);
3090         va_end(ap);
3091
3092         if (r < 0)
3093                 return -ENOMEM;
3094
3095         return unit_write_drop_in_private(u, mode, name, p);
3096 }
3097
3098 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3099         _cleanup_free_ char *p = NULL, *q = NULL;
3100         int r;
3101
3102         assert(u);
3103
3104         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3105                 return 0;
3106
3107         r = drop_in_file(u, mode, name, &p, &q);
3108         if (r < 0)
3109                 return r;
3110
3111         if (unlink(q) < 0)
3112                 r = errno == ENOENT ? 0 : -errno;
3113         else
3114                 r = 1;
3115
3116         rmdir(p);
3117         return r;
3118 }
3119
3120 int unit_make_transient(Unit *u) {
3121         int r;
3122
3123         assert(u);
3124
3125         u->load_state = UNIT_STUB;
3126         u->load_error = 0;
3127         u->transient = true;
3128
3129         free(u->fragment_path);
3130         u->fragment_path = NULL;
3131
3132         if (u->manager->running_as == SYSTEMD_USER) {
3133                 _cleanup_free_ char *c = NULL;
3134
3135                 r = user_config_home(&c);
3136                 if (r < 0)
3137                         return r;
3138                 if (r == 0)
3139                         return -ENOENT;
3140
3141                 u->fragment_path = strjoin(c, "/", u->id, NULL);
3142                 if (!u->fragment_path)
3143                         return -ENOMEM;
3144
3145                 mkdir_p(c, 0755);
3146         } else {
3147                 u->fragment_path = strappend("/run/systemd/system/", u->id);
3148                 if (!u->fragment_path)
3149                         return -ENOMEM;
3150
3151                 mkdir_p("/run/systemd/system", 0755);
3152         }
3153
3154         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3155 }
3156
3157 int unit_kill_context(
3158                 Unit *u,
3159                 KillContext *c,
3160                 bool sigkill,
3161                 pid_t main_pid,
3162                 pid_t control_pid,
3163                 bool main_pid_alien) {
3164
3165         int sig, wait_for_exit = false, r;
3166
3167         assert(u);
3168         assert(c);
3169
3170         if (c->kill_mode == KILL_NONE)
3171                 return 0;
3172
3173         sig = sigkill ? SIGKILL : c->kill_signal;
3174
3175         if (main_pid > 0) {
3176                 r = kill_and_sigcont(main_pid, sig);
3177
3178                 if (r < 0 && r != -ESRCH) {
3179                         _cleanup_free_ char *comm = NULL;
3180                         get_process_comm(main_pid, &comm);
3181
3182                         log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3183                 } else {
3184                         if (!main_pid_alien)
3185                                 wait_for_exit = true;
3186
3187                         if (c->send_sighup && !sigkill)
3188                                 kill(main_pid, SIGHUP);
3189                 }
3190         }
3191
3192         if (control_pid > 0) {
3193                 r = kill_and_sigcont(control_pid, sig);
3194
3195                 if (r < 0 && r != -ESRCH) {
3196                         _cleanup_free_ char *comm = NULL;
3197                         get_process_comm(control_pid, &comm);
3198
3199                         log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3200                 } else {
3201                         wait_for_exit = true;
3202
3203                         if (c->send_sighup && !sigkill)
3204                                 kill(control_pid, SIGHUP);
3205                 }
3206         }
3207
3208         if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3209                 _cleanup_set_free_ Set *pid_set = NULL;
3210
3211                 /* Exclude the main/control pids from being killed via the cgroup */
3212                 pid_set = unit_pid_set(main_pid, control_pid);
3213                 if (!pid_set)
3214                         return -ENOMEM;
3215
3216                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3217                 if (r < 0) {
3218                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3219                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3220                 } else if (r > 0) {
3221
3222                         /* FIXME: For now, we will not wait for the
3223                          * cgroup members to die, simply because
3224                          * cgroup notification is unreliable. It
3225                          * doesn't work at all in containers, and
3226                          * outside of containers it can be confused
3227                          * easily by leaving directories in the
3228                          * cgroup. */
3229
3230                         /* wait_for_exit = true; */
3231
3232                         if (c->send_sighup && !sigkill) {
3233                                 set_free(pid_set);
3234
3235                                 pid_set = unit_pid_set(main_pid, control_pid);
3236                                 if (!pid_set)
3237                                         return -ENOMEM;
3238
3239                                 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3240                         }
3241                 }
3242         }
3243
3244         return wait_for_exit;
3245 }
3246
3247 int unit_require_mounts_for(Unit *u, const char *path) {
3248         char prefix[strlen(path) + 1], *p;
3249         int r;
3250
3251         assert(u);
3252         assert(path);
3253
3254         /* Registers a unit for requiring a certain path and all its
3255          * prefixes. We keep a simple array of these paths in the
3256          * unit, since its usually short. However, we build a prefix
3257          * table for all possible prefixes so that new appearing mount
3258          * units can easily determine which units to make themselves a
3259          * dependency of. */
3260
3261         if (!path_is_absolute(path))
3262                 return -EINVAL;
3263
3264         p = strdup(path);
3265         if (!p)
3266                 return -ENOMEM;
3267
3268         path_kill_slashes(p);
3269
3270         if (!path_is_safe(p)) {
3271                 free(p);
3272                 return -EPERM;
3273         }
3274
3275         if (strv_contains(u->requires_mounts_for, p)) {
3276                 free(p);
3277                 return 0;
3278         }
3279
3280         r = strv_consume(&u->requires_mounts_for, p);
3281         if (r < 0)
3282                 return r;
3283
3284         PATH_FOREACH_PREFIX_MORE(prefix, p) {
3285                 Set *x;
3286
3287                 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3288                 if (!x) {
3289                         char *q;
3290
3291                         if (!u->manager->units_requiring_mounts_for) {
3292                                 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3293                                 if (!u->manager->units_requiring_mounts_for)
3294                                         return -ENOMEM;
3295                         }
3296
3297                         q = strdup(prefix);
3298                         if (!q)
3299                                 return -ENOMEM;
3300
3301                         x = set_new(NULL, NULL);
3302                         if (!x) {
3303                                 free(q);
3304                                 return -ENOMEM;
3305                         }
3306
3307                         r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3308                         if (r < 0) {
3309                                 free(q);
3310                                 set_free(x);
3311                                 return r;
3312                         }
3313                 }
3314
3315                 r = set_put(x, u);
3316                 if (r < 0)
3317                         return r;
3318         }
3319
3320         return 0;
3321 }
3322
3323 int unit_setup_exec_runtime(Unit *u) {
3324         ExecRuntime **rt;
3325         size_t offset;
3326         Iterator i;
3327         Unit *other;
3328
3329         offset = UNIT_VTABLE(u)->exec_runtime_offset;
3330         assert(offset > 0);
3331
3332         /* Check if ther already is an ExecRuntime for this unit? */
3333         rt = (ExecRuntime**) ((uint8_t*) u + offset);
3334         if (*rt)
3335                 return 0;
3336
3337         /* Try to get it from somebody else */
3338         SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3339
3340                 *rt = unit_get_exec_runtime(other);
3341                 if (*rt) {
3342                         exec_runtime_ref(*rt);
3343                         return 0;
3344                 }
3345         }
3346
3347         return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3348 }
3349
3350 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3351         [UNIT_ACTIVE] = "active",
3352         [UNIT_RELOADING] = "reloading",
3353         [UNIT_INACTIVE] = "inactive",
3354         [UNIT_FAILED] = "failed",
3355         [UNIT_ACTIVATING] = "activating",
3356         [UNIT_DEACTIVATING] = "deactivating"
3357 };
3358
3359 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3360
3361 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3362         [UNIT_REQUIRES] = "Requires",
3363         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3364         [UNIT_REQUISITE] = "Requisite",
3365         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3366         [UNIT_WANTS] = "Wants",
3367         [UNIT_BINDS_TO] = "BindsTo",
3368         [UNIT_PART_OF] = "PartOf",
3369         [UNIT_REQUIRED_BY] = "RequiredBy",
3370         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3371         [UNIT_WANTED_BY] = "WantedBy",
3372         [UNIT_BOUND_BY] = "BoundBy",
3373         [UNIT_CONSISTS_OF] = "ConsistsOf",
3374         [UNIT_CONFLICTS] = "Conflicts",
3375         [UNIT_CONFLICTED_BY] = "ConflictedBy",
3376         [UNIT_BEFORE] = "Before",
3377         [UNIT_AFTER] = "After",
3378         [UNIT_ON_FAILURE] = "OnFailure",
3379         [UNIT_TRIGGERS] = "Triggers",
3380         [UNIT_TRIGGERED_BY] = "TriggeredBy",
3381         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3382         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3383         [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3384         [UNIT_REFERENCES] = "References",
3385         [UNIT_REFERENCED_BY] = "ReferencedBy",
3386 };
3387
3388 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);