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         int r;
2292
2293         assert(u);
2294         assert(f);
2295         assert(fds);
2296
2297         if (unit_can_serialize(u)) {
2298                 ExecRuntime *rt;
2299
2300                 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2301                 if (r < 0)
2302                         return r;
2303
2304                 rt = unit_get_exec_runtime(u);
2305                 if (rt) {
2306                         r = exec_runtime_serialize(rt, u, f, fds);
2307                         if (r < 0)
2308                                 return r;
2309                 }
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         ExecRuntime **rt = NULL;
2372         size_t offset;
2373         int r;
2374
2375         assert(u);
2376         assert(f);
2377         assert(fds);
2378
2379         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2380         if (offset > 0)
2381                 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2382
2383         for (;;) {
2384                 char line[LINE_MAX], *l, *v;
2385                 size_t k;
2386
2387                 if (!fgets(line, sizeof(line), f)) {
2388                         if (feof(f))
2389                                 return 0;
2390                         return -errno;
2391                 }
2392
2393                 char_array_0(line);
2394                 l = strstrip(line);
2395
2396                 /* End marker */
2397                 if (l[0] == 0)
2398                         return 0;
2399
2400                 k = strcspn(l, "=");
2401
2402                 if (l[k] == '=') {
2403                         l[k] = 0;
2404                         v = l+k+1;
2405                 } else
2406                         v = l+k;
2407
2408                 if (streq(l, "job")) {
2409                         if (v[0] == '\0') {
2410                                 /* new-style serialized job */
2411                                 Job *j = job_new_raw(u);
2412                                 if (!j)
2413                                         return -ENOMEM;
2414
2415                                 r = job_deserialize(j, f, fds);
2416                                 if (r < 0) {
2417                                         job_free(j);
2418                                         return r;
2419                                 }
2420
2421                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2422                                 if (r < 0) {
2423                                         job_free(j);
2424                                         return r;
2425                                 }
2426
2427                                 r = job_install_deserialized(j);
2428                                 if (r < 0) {
2429                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2430                                         job_free(j);
2431                                         return r;
2432                                 }
2433
2434                                 if (j->state == JOB_RUNNING)
2435                                         u->manager->n_running_jobs++;
2436                         } else {
2437                                 /* legacy */
2438                                 JobType type = job_type_from_string(v);
2439                                 if (type < 0)
2440                                         log_debug("Failed to parse job type value %s", v);
2441                                 else
2442                                         u->deserialized_job = type;
2443                         }
2444                         continue;
2445                 } else if (streq(l, "inactive-exit-timestamp")) {
2446                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2447                         continue;
2448                 } else if (streq(l, "active-enter-timestamp")) {
2449                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2450                         continue;
2451                 } else if (streq(l, "active-exit-timestamp")) {
2452                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2453                         continue;
2454                 } else if (streq(l, "inactive-enter-timestamp")) {
2455                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2456                         continue;
2457                 } else if (streq(l, "condition-timestamp")) {
2458                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2459                         continue;
2460                 } else if (streq(l, "condition-result")) {
2461                         int b;
2462
2463                         b = parse_boolean(v);
2464                         if (b < 0)
2465                                 log_debug("Failed to parse condition result value %s", v);
2466                         else
2467                                 u->condition_result = b;
2468
2469                         continue;
2470
2471                 } else if (streq(l, "transient")) {
2472                         int b;
2473
2474                         b = parse_boolean(v);
2475                         if (b < 0)
2476                                 log_debug("Failed to parse transient bool %s", v);
2477                         else
2478                                 u->transient = b;
2479
2480                         continue;
2481                 } else if (streq(l, "cgroup")) {
2482                         char *s;
2483
2484                         s = strdup(v);
2485                         if (!s)
2486                                 return -ENOMEM;
2487
2488                         if (u->cgroup_path) {
2489                                 void *p;
2490
2491                                 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2492                                 log_info("Removing cgroup_path %s from hashmap (%p)",
2493                                          u->cgroup_path, p);
2494                                 free(u->cgroup_path);
2495                         }
2496
2497                         u->cgroup_path = s;
2498                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2499
2500                         continue;
2501                 }
2502
2503                 if (unit_can_serialize(u)) {
2504                         if (rt) {
2505                                 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2506                                 if (r < 0)
2507                                         return r;
2508                                 if (r > 0)
2509                                         continue;
2510                         }
2511
2512                         r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2513                         if (r < 0)
2514                                 return r;
2515                 }
2516         }
2517 }
2518
2519 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2520         Unit *device;
2521         _cleanup_free_ char *e = NULL;
2522         int r;
2523
2524         assert(u);
2525
2526         if (!what)
2527                 return 0;
2528
2529         /* Adds in links to the device node that this unit is based on */
2530
2531         if (!is_device_path(what))
2532                 return 0;
2533
2534         e = unit_name_from_path(what, ".device");
2535         if (!e)
2536                 return -ENOMEM;
2537
2538         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2539
2540         if (r < 0)
2541                 return r;
2542
2543         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2544         if (r < 0)
2545                 return r;
2546
2547         if (wants) {
2548                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2549                 if (r < 0)
2550                         return r;
2551         }
2552
2553         return 0;
2554 }
2555
2556 int unit_coldplug(Unit *u) {
2557         int r;
2558
2559         assert(u);
2560
2561         if (UNIT_VTABLE(u)->coldplug)
2562                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2563                         return r;
2564
2565         if (u->job) {
2566                 r = job_coldplug(u->job);
2567                 if (r < 0)
2568                         return r;
2569         } else if (u->deserialized_job >= 0) {
2570                 /* legacy */
2571                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2572                 if (r < 0)
2573                         return r;
2574
2575                 u->deserialized_job = _JOB_TYPE_INVALID;
2576         }
2577
2578         return 0;
2579 }
2580
2581 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2582         DISABLE_WARNING_FORMAT_NONLITERAL;
2583         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2584         REENABLE_WARNING;
2585 }
2586
2587 bool unit_need_daemon_reload(Unit *u) {
2588         _cleanup_strv_free_ char **t = NULL;
2589         char **path;
2590         struct stat st;
2591         unsigned loaded_cnt, current_cnt;
2592
2593         assert(u);
2594
2595         if (u->fragment_path) {
2596                 zero(st);
2597                 if (stat(u->fragment_path, &st) < 0)
2598                         /* What, cannot access this anymore? */
2599                         return true;
2600
2601                 if (u->fragment_mtime > 0 &&
2602                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2603                         return true;
2604         }
2605
2606         if (u->source_path) {
2607                 zero(st);
2608                 if (stat(u->source_path, &st) < 0)
2609                         return true;
2610
2611                 if (u->source_mtime > 0 &&
2612                     timespec_load(&st.st_mtim) != u->source_mtime)
2613                         return true;
2614         }
2615
2616         t = unit_find_dropin_paths(u);
2617         loaded_cnt = strv_length(t);
2618         current_cnt = strv_length(u->dropin_paths);
2619
2620         if (loaded_cnt == current_cnt) {
2621                 if (loaded_cnt == 0)
2622                         return false;
2623
2624                 if (strv_overlap(u->dropin_paths, t)) {
2625                         STRV_FOREACH(path, u->dropin_paths) {
2626                                 zero(st);
2627                                 if (stat(*path, &st) < 0)
2628                                         return true;
2629
2630                                 if (u->dropin_mtime > 0 &&
2631                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2632                                         return true;
2633                         }
2634
2635                         return false;
2636                 } else
2637                         return true;
2638         } else
2639                 return true;
2640 }
2641
2642 void unit_reset_failed(Unit *u) {
2643         assert(u);
2644
2645         if (UNIT_VTABLE(u)->reset_failed)
2646                 UNIT_VTABLE(u)->reset_failed(u);
2647 }
2648
2649 Unit *unit_following(Unit *u) {
2650         assert(u);
2651
2652         if (UNIT_VTABLE(u)->following)
2653                 return UNIT_VTABLE(u)->following(u);
2654
2655         return NULL;
2656 }
2657
2658 bool unit_stop_pending(Unit *u) {
2659         assert(u);
2660
2661         /* This call does check the current state of the unit. It's
2662          * hence useful to be called from state change calls of the
2663          * unit itself, where the state isn't updated yet. This is
2664          * different from unit_inactive_or_pending() which checks both
2665          * the current state and for a queued job. */
2666
2667         return u->job && u->job->type == JOB_STOP;
2668 }
2669
2670 bool unit_inactive_or_pending(Unit *u) {
2671         assert(u);
2672
2673         /* Returns true if the unit is inactive or going down */
2674
2675         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2676                 return true;
2677
2678         if (unit_stop_pending(u))
2679                 return true;
2680
2681         return false;
2682 }
2683
2684 bool unit_active_or_pending(Unit *u) {
2685         assert(u);
2686
2687         /* Returns true if the unit is active or going up */
2688
2689         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2690                 return true;
2691
2692         if (u->job &&
2693             (u->job->type == JOB_START ||
2694              u->job->type == JOB_RELOAD_OR_START ||
2695              u->job->type == JOB_RESTART))
2696                 return true;
2697
2698         return false;
2699 }
2700
2701 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2702         assert(u);
2703         assert(w >= 0 && w < _KILL_WHO_MAX);
2704         assert(signo > 0);
2705         assert(signo < _NSIG);
2706
2707         if (!UNIT_VTABLE(u)->kill)
2708                 return -ENOTSUP;
2709
2710         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2711 }
2712
2713 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2714         Set *pid_set;
2715         int r;
2716
2717         pid_set = set_new(trivial_hash_func, trivial_compare_func);
2718         if (!pid_set)
2719                 return NULL;
2720
2721         /* Exclude the main/control pids from being killed via the cgroup */
2722         if (main_pid > 0) {
2723                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2724                 if (r < 0)
2725                         goto fail;
2726         }
2727
2728         if (control_pid > 0) {
2729                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2730                 if (r < 0)
2731                         goto fail;
2732         }
2733
2734         return pid_set;
2735
2736 fail:
2737         set_free(pid_set);
2738         return NULL;
2739 }
2740
2741 int unit_kill_common(
2742                 Unit *u,
2743                 KillWho who,
2744                 int signo,
2745                 pid_t main_pid,
2746                 pid_t control_pid,
2747                 sd_bus_error *error) {
2748
2749         int r = 0;
2750
2751         if (who == KILL_MAIN && main_pid <= 0) {
2752                 if (main_pid < 0)
2753                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2754                 else
2755                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2756                 return -ESRCH;
2757         }
2758
2759         if (who == KILL_CONTROL && control_pid <= 0) {
2760                 if (control_pid < 0)
2761                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2762                 else
2763                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2764                 return -ESRCH;
2765         }
2766
2767         if (who == KILL_CONTROL || who == KILL_ALL)
2768                 if (control_pid > 0)
2769                         if (kill(control_pid, signo) < 0)
2770                                 r = -errno;
2771
2772         if (who == KILL_MAIN || who == KILL_ALL)
2773                 if (main_pid > 0)
2774                         if (kill(main_pid, signo) < 0)
2775                                 r = -errno;
2776
2777         if (who == KILL_ALL && u->cgroup_path) {
2778                 _cleanup_set_free_ Set *pid_set = NULL;
2779                 int q;
2780
2781                 /* Exclude the main/control pids from being killed via the cgroup */
2782                 pid_set = unit_pid_set(main_pid, control_pid);
2783                 if (!pid_set)
2784                         return -ENOMEM;
2785
2786                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2787                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2788                         r = q;
2789         }
2790
2791         return r;
2792 }
2793
2794 int unit_following_set(Unit *u, Set **s) {
2795         assert(u);
2796         assert(s);
2797
2798         if (UNIT_VTABLE(u)->following_set)
2799                 return UNIT_VTABLE(u)->following_set(u, s);
2800
2801         *s = NULL;
2802         return 0;
2803 }
2804
2805 UnitFileState unit_get_unit_file_state(Unit *u) {
2806         assert(u);
2807
2808         if (u->unit_file_state < 0 && u->fragment_path)
2809                 u->unit_file_state = unit_file_get_state(
2810                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2811                                 NULL, basename(u->fragment_path));
2812
2813         return u->unit_file_state;
2814 }
2815
2816 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2817         assert(ref);
2818         assert(u);
2819
2820         if (ref->unit)
2821                 unit_ref_unset(ref);
2822
2823         ref->unit = u;
2824         LIST_PREPEND(refs, u->refs, ref);
2825         return u;
2826 }
2827
2828 void unit_ref_unset(UnitRef *ref) {
2829         assert(ref);
2830
2831         if (!ref->unit)
2832                 return;
2833
2834         LIST_REMOVE(refs, ref->unit->refs, ref);
2835         ref->unit = NULL;
2836 }
2837
2838 int unit_patch_contexts(Unit *u) {
2839         CGroupContext *cc;
2840         ExecContext *ec;
2841         unsigned i;
2842         int r;
2843
2844         assert(u);
2845
2846         /* Patch in the manager defaults into the exec and cgroup
2847          * contexts, _after_ the rest of the settings have been
2848          * initialized */
2849
2850         ec = unit_get_exec_context(u);
2851         if (ec) {
2852                 /* This only copies in the ones that need memory */
2853                 for (i = 0; i < _RLIMIT_MAX; i++)
2854                         if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2855                                 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2856                                 if (!ec->rlimit[i])
2857                                         return -ENOMEM;
2858                         }
2859
2860                 if (u->manager->running_as == SYSTEMD_USER &&
2861                     !ec->working_directory) {
2862
2863                         r = get_home_dir(&ec->working_directory);
2864                         if (r < 0)
2865                                 return r;
2866                 }
2867
2868                 if (u->manager->running_as == SYSTEMD_USER &&
2869                     (ec->syscall_whitelist ||
2870                      !set_isempty(ec->syscall_filter) ||
2871                      !set_isempty(ec->syscall_archs) ||
2872                      ec->address_families_whitelist ||
2873                      !set_isempty(ec->address_families)))
2874                         ec->no_new_privileges = true;
2875
2876                 if (ec->private_devices)
2877                         ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2878         }
2879
2880         cc = unit_get_cgroup_context(u);
2881         if (cc) {
2882
2883                 if (ec &&
2884                     ec->private_devices &&
2885                     cc->device_policy == CGROUP_AUTO)
2886                         cc->device_policy = CGROUP_CLOSED;
2887         }
2888
2889         return 0;
2890 }
2891
2892 ExecContext *unit_get_exec_context(Unit *u) {
2893         size_t offset;
2894         assert(u);
2895
2896         if (u->type < 0)
2897                 return NULL;
2898
2899         offset = UNIT_VTABLE(u)->exec_context_offset;
2900         if (offset <= 0)
2901                 return NULL;
2902
2903         return (ExecContext*) ((uint8_t*) u + offset);
2904 }
2905
2906 KillContext *unit_get_kill_context(Unit *u) {
2907         size_t offset;
2908         assert(u);
2909
2910         if (u->type < 0)
2911                 return NULL;
2912
2913         offset = UNIT_VTABLE(u)->kill_context_offset;
2914         if (offset <= 0)
2915                 return NULL;
2916
2917         return (KillContext*) ((uint8_t*) u + offset);
2918 }
2919
2920 CGroupContext *unit_get_cgroup_context(Unit *u) {
2921         size_t offset;
2922
2923         if (u->type < 0)
2924                 return NULL;
2925
2926         offset = UNIT_VTABLE(u)->cgroup_context_offset;
2927         if (offset <= 0)
2928                 return NULL;
2929
2930         return (CGroupContext*) ((uint8_t*) u + offset);
2931 }
2932
2933 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2934         size_t offset;
2935
2936         if (u->type < 0)
2937                 return NULL;
2938
2939         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2940         if (offset <= 0)
2941                 return NULL;
2942
2943         return *(ExecRuntime**) ((uint8_t*) u + offset);
2944 }
2945
2946 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2947         _cleanup_free_ char *b = NULL;
2948         char *p, *q;
2949         int r;
2950
2951         assert(u);
2952         assert(name);
2953         assert(_p);
2954         assert(_q);
2955
2956         b = xescape(name, "/.");
2957         if (!b)
2958                 return -ENOMEM;
2959
2960         if (!filename_is_safe(b))
2961                 return -EINVAL;
2962
2963         if (u->manager->running_as == SYSTEMD_USER) {
2964                 _cleanup_free_ char *c = NULL;
2965
2966                 r = user_config_home(&c);
2967                 if (r < 0)
2968                         return r;
2969                 if (r == 0)
2970                         return -ENOENT;
2971
2972                 p = strjoin(c, "/", u->id, ".d", NULL);
2973         } else if (mode == UNIT_PERSISTENT && !u->transient)
2974                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2975         else
2976                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2977         if (!p)
2978                 return -ENOMEM;
2979
2980         q = strjoin(p, "/90-", b, ".conf", NULL);
2981         if (!q) {
2982                 free(p);
2983                 return -ENOMEM;
2984         }
2985
2986         *_p = p;
2987         *_q = q;
2988         return 0;
2989 }
2990
2991 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2992         _cleanup_free_ char *p = NULL, *q = NULL;
2993         int r;
2994
2995         assert(u);
2996         assert(name);
2997         assert(data);
2998
2999         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3000                 return 0;
3001
3002         r = drop_in_file(u, mode, name, &p, &q);
3003         if (r < 0)
3004                 return r;
3005
3006         mkdir_p(p, 0755);
3007         return write_string_file_atomic_label(q, data);
3008 }
3009
3010 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3011         _cleanup_free_ char *p = NULL;
3012         va_list ap;
3013         int r;
3014
3015         assert(u);
3016         assert(name);
3017         assert(format);
3018
3019         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3020                 return 0;
3021
3022         va_start(ap, format);
3023         r = vasprintf(&p, format, ap);
3024         va_end(ap);
3025
3026         if (r < 0)
3027                 return -ENOMEM;
3028
3029         return unit_write_drop_in(u, mode, name, p);
3030 }
3031
3032 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3033         _cleanup_free_ char *ndata = NULL;
3034
3035         assert(u);
3036         assert(name);
3037         assert(data);
3038
3039         if (!UNIT_VTABLE(u)->private_section)
3040                 return -EINVAL;
3041
3042         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3043                 return 0;
3044
3045         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3046         if (!ndata)
3047                 return -ENOMEM;
3048
3049         return unit_write_drop_in(u, mode, name, ndata);
3050 }
3051
3052 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3053         _cleanup_free_ char *p = NULL;
3054         va_list ap;
3055         int r;
3056
3057         assert(u);
3058         assert(name);
3059         assert(format);
3060
3061         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3062                 return 0;
3063
3064         va_start(ap, format);
3065         r = vasprintf(&p, format, ap);
3066         va_end(ap);
3067
3068         if (r < 0)
3069                 return -ENOMEM;
3070
3071         return unit_write_drop_in_private(u, mode, name, p);
3072 }
3073
3074 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3075         _cleanup_free_ char *p = NULL, *q = NULL;
3076         int r;
3077
3078         assert(u);
3079
3080         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3081                 return 0;
3082
3083         r = drop_in_file(u, mode, name, &p, &q);
3084         if (r < 0)
3085                 return r;
3086
3087         if (unlink(q) < 0)
3088                 r = errno == ENOENT ? 0 : -errno;
3089         else
3090                 r = 1;
3091
3092         rmdir(p);
3093         return r;
3094 }
3095
3096 int unit_make_transient(Unit *u) {
3097         int r;
3098
3099         assert(u);
3100
3101         u->load_state = UNIT_STUB;
3102         u->load_error = 0;
3103         u->transient = true;
3104
3105         free(u->fragment_path);
3106         u->fragment_path = NULL;
3107
3108         if (u->manager->running_as == SYSTEMD_USER) {
3109                 _cleanup_free_ char *c = NULL;
3110
3111                 r = user_config_home(&c);
3112                 if (r < 0)
3113                         return r;
3114                 if (r == 0)
3115                         return -ENOENT;
3116
3117                 u->fragment_path = strjoin(c, "/", u->id, NULL);
3118                 if (!u->fragment_path)
3119                         return -ENOMEM;
3120
3121                 mkdir_p(c, 0755);
3122         } else {
3123                 u->fragment_path = strappend("/run/systemd/system/", u->id);
3124                 if (!u->fragment_path)
3125                         return -ENOMEM;
3126
3127                 mkdir_p("/run/systemd/system", 0755);
3128         }
3129
3130         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3131 }
3132
3133 int unit_kill_context(
3134                 Unit *u,
3135                 KillContext *c,
3136                 bool sigkill,
3137                 pid_t main_pid,
3138                 pid_t control_pid,
3139                 bool main_pid_alien) {
3140
3141         int sig, wait_for_exit = false, r;
3142
3143         assert(u);
3144         assert(c);
3145
3146         if (c->kill_mode == KILL_NONE)
3147                 return 0;
3148
3149         sig = sigkill ? SIGKILL : c->kill_signal;
3150
3151         if (main_pid > 0) {
3152                 r = kill_and_sigcont(main_pid, sig);
3153
3154                 if (r < 0 && r != -ESRCH) {
3155                         _cleanup_free_ char *comm = NULL;
3156                         get_process_comm(main_pid, &comm);
3157
3158                         log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3159                 } else {
3160                         if (!main_pid_alien)
3161                                 wait_for_exit = true;
3162
3163                         if (c->send_sighup && !sigkill)
3164                                 kill(main_pid, SIGHUP);
3165                 }
3166         }
3167
3168         if (control_pid > 0) {
3169                 r = kill_and_sigcont(control_pid, sig);
3170
3171                 if (r < 0 && r != -ESRCH) {
3172                         _cleanup_free_ char *comm = NULL;
3173                         get_process_comm(control_pid, &comm);
3174
3175                         log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3176                 } else {
3177                         wait_for_exit = true;
3178
3179                         if (c->send_sighup && !sigkill)
3180                                 kill(control_pid, SIGHUP);
3181                 }
3182         }
3183
3184         if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3185                 _cleanup_set_free_ Set *pid_set = NULL;
3186
3187                 /* Exclude the main/control pids from being killed via the cgroup */
3188                 pid_set = unit_pid_set(main_pid, control_pid);
3189                 if (!pid_set)
3190                         return -ENOMEM;
3191
3192                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3193                 if (r < 0) {
3194                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3195                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3196                 } else if (r > 0) {
3197
3198                         /* FIXME: For now, we will not wait for the
3199                          * cgroup members to die, simply because
3200                          * cgroup notification is unreliable. It
3201                          * doesn't work at all in containers, and
3202                          * outside of containers it can be confused
3203                          * easily by leaving directories in the
3204                          * cgroup. */
3205
3206                         /* wait_for_exit = true; */
3207
3208                         if (c->send_sighup && !sigkill) {
3209                                 set_free(pid_set);
3210
3211                                 pid_set = unit_pid_set(main_pid, control_pid);
3212                                 if (!pid_set)
3213                                         return -ENOMEM;
3214
3215                                 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3216                         }
3217                 }
3218         }
3219
3220         return wait_for_exit;
3221 }
3222
3223 int unit_require_mounts_for(Unit *u, const char *path) {
3224         char prefix[strlen(path) + 1], *p;
3225         int r;
3226
3227         assert(u);
3228         assert(path);
3229
3230         /* Registers a unit for requiring a certain path and all its
3231          * prefixes. We keep a simple array of these paths in the
3232          * unit, since its usually short. However, we build a prefix
3233          * table for all possible prefixes so that new appearing mount
3234          * units can easily determine which units to make themselves a
3235          * dependency of. */
3236
3237         if (!path_is_absolute(path))
3238                 return -EINVAL;
3239
3240         p = strdup(path);
3241         if (!p)
3242                 return -ENOMEM;
3243
3244         path_kill_slashes(p);
3245
3246         if (!path_is_safe(p)) {
3247                 free(p);
3248                 return -EPERM;
3249         }
3250
3251         if (strv_contains(u->requires_mounts_for, p)) {
3252                 free(p);
3253                 return 0;
3254         }
3255
3256         r = strv_consume(&u->requires_mounts_for, p);
3257         if (r < 0)
3258                 return r;
3259
3260         PATH_FOREACH_PREFIX_MORE(prefix, p) {
3261                 Set *x;
3262
3263                 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3264                 if (!x) {
3265                         char *q;
3266
3267                         if (!u->manager->units_requiring_mounts_for) {
3268                                 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3269                                 if (!u->manager->units_requiring_mounts_for)
3270                                         return -ENOMEM;
3271                         }
3272
3273                         q = strdup(prefix);
3274                         if (!q)
3275                                 return -ENOMEM;
3276
3277                         x = set_new(NULL, NULL);
3278                         if (!x) {
3279                                 free(q);
3280                                 return -ENOMEM;
3281                         }
3282
3283                         r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3284                         if (r < 0) {
3285                                 free(q);
3286                                 set_free(x);
3287                                 return r;
3288                         }
3289                 }
3290
3291                 r = set_put(x, u);
3292                 if (r < 0)
3293                         return r;
3294         }
3295
3296         return 0;
3297 }
3298
3299 int unit_setup_exec_runtime(Unit *u) {
3300         ExecRuntime **rt;
3301         size_t offset;
3302         Iterator i;
3303         Unit *other;
3304
3305         offset = UNIT_VTABLE(u)->exec_runtime_offset;
3306         assert(offset > 0);
3307
3308         /* Check if ther already is an ExecRuntime for this unit? */
3309         rt = (ExecRuntime**) ((uint8_t*) u + offset);
3310         if (*rt)
3311                 return 0;
3312
3313         /* Try to get it from somebody else */
3314         SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3315
3316                 *rt = unit_get_exec_runtime(other);
3317                 if (*rt) {
3318                         exec_runtime_ref(*rt);
3319                         return 0;
3320                 }
3321         }
3322
3323         return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3324 }
3325
3326 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3327         [UNIT_ACTIVE] = "active",
3328         [UNIT_RELOADING] = "reloading",
3329         [UNIT_INACTIVE] = "inactive",
3330         [UNIT_FAILED] = "failed",
3331         [UNIT_ACTIVATING] = "activating",
3332         [UNIT_DEACTIVATING] = "deactivating"
3333 };
3334
3335 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3336
3337 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3338         [UNIT_REQUIRES] = "Requires",
3339         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3340         [UNIT_REQUISITE] = "Requisite",
3341         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3342         [UNIT_WANTS] = "Wants",
3343         [UNIT_BINDS_TO] = "BindsTo",
3344         [UNIT_PART_OF] = "PartOf",
3345         [UNIT_REQUIRED_BY] = "RequiredBy",
3346         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3347         [UNIT_WANTED_BY] = "WantedBy",
3348         [UNIT_BOUND_BY] = "BoundBy",
3349         [UNIT_CONSISTS_OF] = "ConsistsOf",
3350         [UNIT_CONFLICTS] = "Conflicts",
3351         [UNIT_CONFLICTED_BY] = "ConflictedBy",
3352         [UNIT_BEFORE] = "Before",
3353         [UNIT_AFTER] = "After",
3354         [UNIT_ON_FAILURE] = "OnFailure",
3355         [UNIT_TRIGGERS] = "Triggers",
3356         [UNIT_TRIGGERED_BY] = "TriggeredBy",
3357         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3358         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3359         [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3360         [UNIT_REFERENCES] = "References",
3361         [UNIT_REFERENCED_BY] = "ReferencedBy",
3362 };
3363
3364 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);