src/core/unit.c

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