src/core/unit.c

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