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 static int unit_add_startup_units(Unit *u) {
1075         CGroupContext *c;
1076         int r = 0;
1077
1078         c = unit_get_cgroup_context(u);
1079         if (c != NULL && manager_state(u->manager) == MANAGER_STARTING &&
1080             (c->startup_cpu_shares_set || c->startup_blockio_weight_set)) {
1081                 r = set_put(u->manager->startup_units, u);
1082                 if (r == -EEXIST)
1083                         r = 0;
1084         }
1085         return r;
1086 }
1087
1088 int unit_load(Unit *u) {
1089         int r;
1090
1091         assert(u);
1092
1093         if (u->in_load_queue) {
1094                 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1095                 u->in_load_queue = false;
1096         }
1097
1098         if (u->type == _UNIT_TYPE_INVALID)
1099                 return -EINVAL;
1100
1101         if (u->load_state != UNIT_STUB)
1102                 return 0;
1103
1104         if (UNIT_VTABLE(u)->load) {
1105                 r = UNIT_VTABLE(u)->load(u);
1106                 if (r < 0)
1107                         goto fail;
1108         }
1109
1110         if (u->load_state == UNIT_STUB) {
1111                 r = -ENOENT;
1112                 goto fail;
1113         }
1114
1115         if (u->load_state == UNIT_LOADED) {
1116
1117                 r = unit_add_target_dependencies(u);
1118                 if (r < 0)
1119                         goto fail;
1120
1121                 r = unit_add_slice_dependencies(u);
1122                 if (r < 0)
1123                         goto fail;
1124
1125                 r = unit_add_mount_dependencies(u);
1126                 if (r < 0)
1127                         goto fail;
1128
1129                 r = unit_add_startup_units(u);
1130                 if (r < 0)
1131                         goto fail;
1132
1133                 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1134                         log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1135                         r = -EINVAL;
1136                         goto fail;
1137                 }
1138
1139                 unit_update_cgroup_members_masks(u);
1140         }
1141
1142         assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1143
1144         unit_add_to_dbus_queue(unit_follow_merge(u));
1145         unit_add_to_gc_queue(u);
1146
1147         return 0;
1148
1149 fail:
1150         u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1151         u->load_error = r;
1152         unit_add_to_dbus_queue(u);
1153         unit_add_to_gc_queue(u);
1154
1155         log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1156                        u->id, strerror(-r));
1157
1158         return r;
1159 }
1160
1161 static bool unit_condition_test(Unit *u) {
1162         assert(u);
1163
1164         dual_timestamp_get(&u->condition_timestamp);
1165         u->condition_result = condition_test_list(u->id, u->conditions);
1166
1167         return u->condition_result;
1168 }
1169
1170 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1171         const UnitStatusMessageFormats *format_table;
1172
1173         assert(u);
1174         assert(t >= 0);
1175         assert(t < _JOB_TYPE_MAX);
1176
1177         if (t != JOB_START && t != JOB_STOP)
1178                 return NULL;
1179
1180         format_table = &UNIT_VTABLE(u)->status_message_formats;
1181         if (!format_table)
1182                 return NULL;
1183
1184         return format_table->starting_stopping[t == JOB_STOP];
1185 }
1186
1187 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1188         const char *format;
1189
1190         assert(u);
1191         assert(t >= 0);
1192         assert(t < _JOB_TYPE_MAX);
1193
1194         format = unit_get_status_message_format(u, t);
1195         if (format)
1196                 return format;
1197
1198         /* Return generic strings */
1199         if (t == JOB_START)
1200                 return "Starting %s.";
1201         else if (t == JOB_STOP)
1202                 return "Stopping %s.";
1203         else if (t == JOB_RELOAD)
1204                 return "Reloading %s.";
1205
1206         return NULL;
1207 }
1208
1209 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1210         const char *format;
1211
1212         assert(u);
1213
1214         /* We only print status messages for selected units on
1215          * selected operations. */
1216
1217         format = unit_get_status_message_format(u, t);
1218         if (!format)
1219                 return;
1220
1221         DISABLE_WARNING_FORMAT_NONLITERAL;
1222         unit_status_printf(u, "", format);
1223         REENABLE_WARNING;
1224 }
1225
1226 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1227         const char *format;
1228         char buf[LINE_MAX];
1229         sd_id128_t mid;
1230
1231         assert(u);
1232
1233         if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1234                 return;
1235
1236         if (log_on_console())
1237                 return;
1238
1239         /* We log status messages for all units and all operations. */
1240
1241         format = unit_get_status_message_format_try_harder(u, t);
1242         if (!format)
1243                 return;
1244
1245         DISABLE_WARNING_FORMAT_NONLITERAL;
1246         snprintf(buf, sizeof(buf), format, unit_description(u));
1247         char_array_0(buf);
1248         REENABLE_WARNING;
1249
1250         mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1251               t == JOB_STOP  ? SD_MESSAGE_UNIT_STOPPING :
1252                                SD_MESSAGE_UNIT_RELOADING;
1253
1254         log_struct_unit(LOG_INFO,
1255                         u->id,
1256                         MESSAGE_ID(mid),
1257                         "MESSAGE=%s", buf,
1258                         NULL);
1259 }
1260
1261 /* Errors:
1262  *         -EBADR:     This unit type does not support starting.
1263  *         -EALREADY:  Unit is already started.
1264  *         -EAGAIN:    An operation is already in progress. Retry later.
1265  *         -ECANCELED: Too many requests for now.
1266  */
1267 int unit_start(Unit *u) {
1268         UnitActiveState state;
1269         Unit *following;
1270
1271         assert(u);
1272
1273         if (u->load_state != UNIT_LOADED)
1274                 return -EINVAL;
1275
1276         /* If this is already started, then this will succeed. Note
1277          * that this will even succeed if this unit is not startable
1278          * by the user. This is relied on to detect when we need to
1279          * wait for units and when waiting is finished. */
1280         state = unit_active_state(u);
1281         if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1282                 return -EALREADY;
1283
1284         /* If the conditions failed, don't do anything at all. If we
1285          * already are activating this call might still be useful to
1286          * speed up activation in case there is some hold-off time,
1287          * but we don't want to recheck the condition in that case. */
1288         if (state != UNIT_ACTIVATING &&
1289             !unit_condition_test(u)) {
1290                 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1291                 return -EALREADY;
1292         }
1293
1294         /* Forward to the main object, if we aren't it. */
1295         following = unit_following(u);
1296         if (following) {
1297                 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1298                                u->id, following->id);
1299                 return unit_start(following);
1300         }
1301
1302         unit_status_log_starting_stopping_reloading(u, JOB_START);
1303         unit_status_print_starting_stopping(u, JOB_START);
1304
1305         /* If it is stopped, but we cannot start it, then fail */
1306         if (!UNIT_VTABLE(u)->start)
1307                 return -EBADR;
1308
1309         /* We don't suppress calls to ->start() here when we are
1310          * already starting, to allow this request to be used as a
1311          * "hurry up" call, for example when the unit is in some "auto
1312          * restart" state where it waits for a holdoff timer to elapse
1313          * before it will start again. */
1314
1315         unit_add_to_dbus_queue(u);
1316
1317         return UNIT_VTABLE(u)->start(u);
1318 }
1319
1320 bool unit_can_start(Unit *u) {
1321         assert(u);
1322
1323         return !!UNIT_VTABLE(u)->start;
1324 }
1325
1326 bool unit_can_isolate(Unit *u) {
1327         assert(u);
1328
1329         return unit_can_start(u) &&
1330                 u->allow_isolate;
1331 }
1332
1333 /* Errors:
1334  *         -EBADR:    This unit type does not support stopping.
1335  *         -EALREADY: Unit is already stopped.
1336  *         -EAGAIN:   An operation is already in progress. Retry later.
1337  */
1338 int unit_stop(Unit *u) {
1339         UnitActiveState state;
1340         Unit *following;
1341
1342         assert(u);
1343
1344         state = unit_active_state(u);
1345         if (UNIT_IS_INACTIVE_OR_FAILED(state))
1346                 return -EALREADY;
1347
1348         if ((following = unit_following(u))) {
1349                 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1350                                u->id, following->id);
1351                 return unit_stop(following);
1352         }
1353
1354         unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1355         unit_status_print_starting_stopping(u, JOB_STOP);
1356
1357         if (!UNIT_VTABLE(u)->stop)
1358                 return -EBADR;
1359
1360         unit_add_to_dbus_queue(u);
1361
1362         return UNIT_VTABLE(u)->stop(u);
1363 }
1364
1365 /* Errors:
1366  *         -EBADR:    This unit type does not support reloading.
1367  *         -ENOEXEC:  Unit is not started.
1368  *         -EAGAIN:   An operation is already in progress. Retry later.
1369  */
1370 int unit_reload(Unit *u) {
1371         UnitActiveState state;
1372         Unit *following;
1373
1374         assert(u);
1375
1376         if (u->load_state != UNIT_LOADED)
1377                 return -EINVAL;
1378
1379         if (!unit_can_reload(u))
1380                 return -EBADR;
1381
1382         state = unit_active_state(u);
1383         if (state == UNIT_RELOADING)
1384                 return -EALREADY;
1385
1386         if (state != UNIT_ACTIVE) {
1387                 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1388                                  u->id);
1389                 return -ENOEXEC;
1390         }
1391
1392         following = unit_following(u);
1393         if (following) {
1394                 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1395                                u->id, following->id);
1396                 return unit_reload(following);
1397         }
1398
1399         unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1400
1401         unit_add_to_dbus_queue(u);
1402         return UNIT_VTABLE(u)->reload(u);
1403 }
1404
1405 bool unit_can_reload(Unit *u) {
1406         assert(u);
1407
1408         if (!UNIT_VTABLE(u)->reload)
1409                 return false;
1410
1411         if (!UNIT_VTABLE(u)->can_reload)
1412                 return true;
1413
1414         return UNIT_VTABLE(u)->can_reload(u);
1415 }
1416
1417 static void unit_check_unneeded(Unit *u) {
1418         Iterator i;
1419         Unit *other;
1420
1421         assert(u);
1422
1423         /* If this service shall be shut down when unneeded then do
1424          * so. */
1425
1426         if (!u->stop_when_unneeded)
1427                 return;
1428
1429         if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1430                 return;
1431
1432         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1433                 if (unit_active_or_pending(other))
1434                         return;
1435
1436         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1437                 if (unit_active_or_pending(other))
1438                         return;
1439
1440         SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1441                 if (unit_active_or_pending(other))
1442                         return;
1443
1444         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1445                 if (unit_active_or_pending(other))
1446                         return;
1447
1448         log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1449
1450         /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1451         manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1452 }
1453
1454 static void retroactively_start_dependencies(Unit *u) {
1455         Iterator i;
1456         Unit *other;
1457
1458         assert(u);
1459         assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1460
1461         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1462                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1463                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1464                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1465
1466         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1467                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1468                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1469                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1470
1471         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1472                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1473                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1474                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1475
1476         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1477                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1478                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1479                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1480
1481         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1482                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1483                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1484
1485         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1486                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1487                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1488 }
1489
1490 static void retroactively_stop_dependencies(Unit *u) {
1491         Iterator i;
1492         Unit *other;
1493
1494         assert(u);
1495         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1496
1497         /* Pull down units which are bound to us recursively if enabled */
1498         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1499                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1500                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1501 }
1502
1503 static void check_unneeded_dependencies(Unit *u) {
1504         Iterator i;
1505         Unit *other;
1506
1507         assert(u);
1508         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1509
1510         /* Garbage collect services that might not be needed anymore, if enabled */
1511         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1512                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1513                         unit_check_unneeded(other);
1514         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1515                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1516                         unit_check_unneeded(other);
1517         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1518                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1519                         unit_check_unneeded(other);
1520         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1521                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1522                         unit_check_unneeded(other);
1523         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1524                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1525                         unit_check_unneeded(other);
1526         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1527                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1528                         unit_check_unneeded(other);
1529 }
1530
1531 void unit_start_on_failure(Unit *u) {
1532         Unit *other;
1533         Iterator i;
1534
1535         assert(u);
1536
1537         if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1538                 return;
1539
1540         log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1541
1542         SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1543                 int r;
1544
1545                 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1546                 if (r < 0)
1547                         log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1548         }
1549 }
1550
1551 void unit_trigger_notify(Unit *u) {
1552         Unit *other;
1553         Iterator i;
1554
1555         assert(u);
1556
1557         SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1558                 if (UNIT_VTABLE(other)->trigger_notify)
1559                         UNIT_VTABLE(other)->trigger_notify(other, u);
1560 }
1561
1562 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1563         Manager *m;
1564         bool unexpected;
1565
1566         assert(u);
1567         assert(os < _UNIT_ACTIVE_STATE_MAX);
1568         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1569
1570         /* Note that this is called for all low-level state changes,
1571          * even if they might map to the same high-level
1572          * UnitActiveState! That means that ns == os is OK an expected
1573          * behavior here. For example: if a mount point is remounted
1574          * this function will be called too! */
1575
1576         m = u->manager;
1577
1578         /* Update timestamps for state changes */
1579         if (m->n_reloading <= 0) {
1580                 dual_timestamp ts;
1581
1582                 dual_timestamp_get(&ts);
1583
1584                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1585                         u->inactive_exit_timestamp = ts;
1586                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1587                         u->inactive_enter_timestamp = ts;
1588
1589                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1590                         u->active_enter_timestamp = ts;
1591                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1592                         u->active_exit_timestamp = ts;
1593         }
1594
1595         /* Keep track of failed of units */
1596         if (ns == UNIT_FAILED && os != UNIT_FAILED)
1597                 set_put(u->manager->failed_units, u);
1598         else if (os == UNIT_FAILED && ns != UNIT_FAILED)
1599                 set_remove(u->manager->failed_units, u);
1600
1601         /* Make sure the cgroup is always removed when we become inactive */
1602         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1603                 unit_destroy_cgroup(u);
1604
1605         /* Note that this doesn't apply to RemainAfterExit services exiting
1606          * successfully, since there's no change of state in that case. Which is
1607          * why it is handled in service_set_state() */
1608         if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1609                 ExecContext *ec;
1610
1611                 ec = unit_get_exec_context(u);
1612                 if (ec && exec_context_may_touch_console(ec)) {
1613                         if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1614                                 m->n_on_console --;
1615
1616                                 if (m->n_on_console == 0)
1617                                         /* unset no_console_output flag, since the console is free */
1618                                         m->no_console_output = false;
1619                         } else
1620                                 m->n_on_console ++;
1621                 }
1622         }
1623
1624         if (u->job) {
1625                 unexpected = false;
1626
1627                 if (u->job->state == JOB_WAITING)
1628
1629                         /* So we reached a different state for this
1630                          * job. Let's see if we can run it now if it
1631                          * failed previously due to EAGAIN. */
1632                         job_add_to_run_queue(u->job);
1633
1634                 /* Let's check whether this state change constitutes a
1635                  * finished job, or maybe contradicts a running job and
1636                  * hence needs to invalidate jobs. */
1637
1638                 switch (u->job->type) {
1639
1640                 case JOB_START:
1641                 case JOB_VERIFY_ACTIVE:
1642
1643                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1644                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1645                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1646                                 unexpected = true;
1647
1648                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1649                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1650                         }
1651
1652                         break;
1653
1654                 case JOB_RELOAD:
1655                 case JOB_RELOAD_OR_START:
1656
1657                         if (u->job->state == JOB_RUNNING) {
1658                                 if (ns == UNIT_ACTIVE)
1659                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1660                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1661                                         unexpected = true;
1662
1663                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1664                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1665                                 }
1666                         }
1667
1668                         break;
1669
1670                 case JOB_STOP:
1671                 case JOB_RESTART:
1672                 case JOB_TRY_RESTART:
1673
1674                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1675                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1676                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1677                                 unexpected = true;
1678                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1679                         }
1680
1681                         break;
1682
1683                 default:
1684                         assert_not_reached("Job type unknown");
1685                 }
1686
1687         } else
1688                 unexpected = true;
1689
1690         if (m->n_reloading <= 0) {
1691
1692                 /* If this state change happened without being
1693                  * requested by a job, then let's retroactively start
1694                  * or stop dependencies. We skip that step when
1695                  * deserializing, since we don't want to create any
1696                  * additional jobs just because something is already
1697                  * activated. */
1698
1699                 if (unexpected) {
1700                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1701                                 retroactively_start_dependencies(u);
1702                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1703                                 retroactively_stop_dependencies(u);
1704                 }
1705
1706                 /* stop unneeded units regardless if going down was expected or not */
1707                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1708                         check_unneeded_dependencies(u);
1709
1710                 if (ns != os && ns == UNIT_FAILED) {
1711                         log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1712                         unit_start_on_failure(u);
1713                 }
1714         }
1715
1716         /* Some names are special */
1717         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1718
1719                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1720                         /* The bus just might have become available,
1721                          * hence try to connect to it, if we aren't
1722                          * yet connected. */
1723                         bus_init(m, true);
1724
1725                 if (u->type == UNIT_SERVICE &&
1726                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1727                     m->n_reloading <= 0) {
1728                         /* Write audit record if we have just finished starting up */
1729                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1730                         u->in_audit = true;
1731                 }
1732
1733                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1734                         manager_send_unit_plymouth(m, u);
1735
1736         } else {
1737
1738                 /* We don't care about D-Bus here, since we'll get an
1739                  * asynchronous notification for it anyway. */
1740
1741                 if (u->type == UNIT_SERVICE &&
1742                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1743                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1744                     m->n_reloading <= 0) {
1745
1746                         /* Hmm, if there was no start record written
1747                          * write it now, so that we always have a nice
1748                          * pair */
1749                         if (!u->in_audit) {
1750                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1751
1752                                 if (ns == UNIT_INACTIVE)
1753                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1754                         } else
1755                                 /* Write audit record if we have just finished shutting down */
1756                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1757
1758                         u->in_audit = false;
1759                 }
1760         }
1761
1762         manager_recheck_journal(m);
1763         unit_trigger_notify(u);
1764
1765         /* Maybe we finished startup and are now ready for being
1766          * stopped because unneeded? */
1767         if (u->manager->n_reloading <= 0)
1768                 unit_check_unneeded(u);
1769
1770         unit_add_to_dbus_queue(u);
1771         unit_add_to_gc_queue(u);
1772 }
1773
1774 int unit_watch_pid(Unit *u, pid_t pid) {
1775         int q, r;
1776
1777         assert(u);
1778         assert(pid >= 1);
1779
1780         /* Watch a specific PID. We only support one or two units
1781          * watching each PID for now, not more. */
1782
1783         r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1784         if (r < 0)
1785                 return r;
1786
1787         r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1788         if (r < 0)
1789                 return r;
1790
1791         r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1792         if (r == -EEXIST) {
1793                 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1794                 if (r < 0)
1795                         return r;
1796
1797                 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1798         }
1799
1800         q = set_put(u->pids, LONG_TO_PTR(pid));
1801         if (q < 0)
1802                 return q;
1803
1804         return r;
1805 }
1806
1807 void unit_unwatch_pid(Unit *u, pid_t pid) {
1808         assert(u);
1809         assert(pid >= 1);
1810
1811         hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1812         hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1813         set_remove(u->pids, LONG_TO_PTR(pid));
1814 }
1815
1816 void unit_unwatch_all_pids(Unit *u) {
1817         assert(u);
1818
1819         while (!set_isempty(u->pids))
1820                 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
1821
1822         set_free(u->pids);
1823         u->pids = NULL;
1824 }
1825
1826 static int unit_watch_pids_in_path(Unit *u, const char *path) {
1827         _cleanup_closedir_ DIR *d = NULL;
1828         _cleanup_fclose_ FILE *f = NULL;
1829         int ret = 0, r;
1830
1831         assert(u);
1832         assert(path);
1833
1834         /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1835
1836         r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1837         if (r >= 0) {
1838                 pid_t pid;
1839
1840                 while ((r = cg_read_pid(f, &pid)) > 0) {
1841                         r = unit_watch_pid(u, pid);
1842                         if (r < 0 && ret >= 0)
1843                                 ret = r;
1844                 }
1845                 if (r < 0 && ret >= 0)
1846                         ret = r;
1847
1848         } else if (ret >= 0)
1849                 ret = r;
1850
1851         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1852         if (r >= 0) {
1853                 char *fn;
1854
1855                 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1856                         _cleanup_free_ char *p = NULL;
1857
1858                         p = strjoin(path, "/", fn, NULL);
1859                         free(fn);
1860
1861                         if (!p)
1862                                 return -ENOMEM;
1863
1864                         r = unit_watch_pids_in_path(u, p);
1865                         if (r < 0 && ret >= 0)
1866                                 ret = r;
1867                 }
1868                 if (r < 0 && ret >= 0)
1869                         ret = r;
1870
1871         } else if (ret >= 0)
1872                 ret = r;
1873
1874         return ret;
1875 }
1876
1877 int unit_watch_all_pids(Unit *u) {
1878         assert(u);
1879
1880         /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1881
1882         if (!u->cgroup_path)
1883                 return -ENOENT;
1884
1885         return unit_watch_pids_in_path(u, u->cgroup_path);
1886 }
1887
1888 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1889         Iterator i;
1890         void *e;
1891
1892         assert(u);
1893
1894         /* Cleans dead PIDs from our list */
1895
1896         SET_FOREACH(e, u->pids, i) {
1897                 pid_t pid = PTR_TO_LONG(e);
1898
1899                 if (pid == except1 || pid == except2)
1900                         continue;
1901
1902                 if (!pid_is_unwaited(pid))
1903                         unit_unwatch_pid(u, pid);
1904         }
1905 }
1906
1907 bool unit_job_is_applicable(Unit *u, JobType j) {
1908         assert(u);
1909         assert(j >= 0 && j < _JOB_TYPE_MAX);
1910
1911         switch (j) {
1912
1913         case JOB_VERIFY_ACTIVE:
1914         case JOB_START:
1915         case JOB_STOP:
1916         case JOB_NOP:
1917                 return true;
1918
1919         case JOB_RESTART:
1920         case JOB_TRY_RESTART:
1921                 return unit_can_start(u);
1922
1923         case JOB_RELOAD:
1924                 return unit_can_reload(u);
1925
1926         case JOB_RELOAD_OR_START:
1927                 return unit_can_reload(u) && unit_can_start(u);
1928
1929         default:
1930                 assert_not_reached("Invalid job type");
1931         }
1932 }
1933
1934 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1935
1936         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1937                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1938                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1939                 [UNIT_WANTS] = UNIT_WANTED_BY,
1940                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1941                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1942                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1943                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1944                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1945                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1946                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1947                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1948                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1949                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1950                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1951                 [UNIT_BEFORE] = UNIT_AFTER,
1952                 [UNIT_AFTER] = UNIT_BEFORE,
1953                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1954                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1955                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1956                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1957                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1958                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1959                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1960                 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1961         };
1962         int r, q = 0, v = 0, w = 0;
1963
1964         assert(u);
1965         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1966         assert(other);
1967
1968         u = unit_follow_merge(u);
1969         other = unit_follow_merge(other);
1970
1971         /* We won't allow dependencies on ourselves. We will not
1972          * consider them an error however. */
1973         if (u == other)
1974                 return 0;
1975
1976         r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1977         if (r < 0)
1978                 return r;
1979
1980         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1981                 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1982                 if (r < 0)
1983                         return r;
1984         }
1985
1986         if (add_reference) {
1987                 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1988                 if (r < 0)
1989                         return r;
1990
1991                 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1992                 if (r < 0)
1993                         return r;
1994         }
1995
1996         q = set_put(u->dependencies[d], other);
1997         if (q < 0)
1998                 return q;
1999
2000         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2001                 v = set_put(other->dependencies[inverse_table[d]], u);
2002                 if (v < 0) {
2003                         r = v;
2004                         goto fail;
2005                 }
2006         }
2007
2008         if (add_reference) {
2009                 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2010                 if (w < 0) {
2011                         r = w;
2012                         goto fail;
2013                 }
2014
2015                 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2016                 if (r < 0)
2017                         goto fail;
2018         }
2019
2020         unit_add_to_dbus_queue(u);
2021         return 0;
2022
2023 fail:
2024         if (q > 0)
2025                 set_remove(u->dependencies[d], other);
2026
2027         if (v > 0)
2028                 set_remove(other->dependencies[inverse_table[d]], u);
2029
2030         if (w > 0)
2031                 set_remove(u->dependencies[UNIT_REFERENCES], other);
2032
2033         return r;
2034 }
2035
2036 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2037         int r;
2038
2039         assert(u);
2040
2041         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
2042                 return r;
2043
2044         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
2045                 return r;
2046
2047         return 0;
2048 }
2049
2050 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
2051         char *s;
2052
2053         assert(u);
2054         assert(name || path);
2055         assert(p);
2056
2057         if (!name)
2058                 name = basename(path);
2059
2060         if (!unit_name_is_template(name)) {
2061                 *p = NULL;
2062                 return name;
2063         }
2064
2065         if (u->instance)
2066                 s = unit_name_replace_instance(name, u->instance);
2067         else {
2068                 _cleanup_free_ char *i = NULL;
2069
2070                 i = unit_name_to_prefix(u->id);
2071                 if (!i)
2072                         return NULL;
2073
2074                 s = unit_name_replace_instance(name, i);
2075         }
2076
2077         if (!s)
2078                 return NULL;
2079
2080         *p = s;
2081         return s;
2082 }
2083
2084 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2085         Unit *other;
2086         int r;
2087         _cleanup_free_ char *s = NULL;
2088
2089         assert(u);
2090         assert(name || path);
2091
2092         name = resolve_template(u, name, path, &s);
2093         if (!name)
2094                 return -ENOMEM;
2095
2096         r = manager_load_unit(u->manager, name, path, NULL, &other);
2097         if (r < 0)
2098                 return r;
2099
2100         return unit_add_dependency(u, d, other, add_reference);
2101 }
2102
2103 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2104         Unit *other;
2105         int r;
2106         _cleanup_free_ char *s = NULL;
2107
2108         assert(u);
2109         assert(name || path);
2110
2111         if (!(name = resolve_template(u, name, path, &s)))
2112                 return -ENOMEM;
2113
2114         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2115                 return r;
2116
2117         r = unit_add_two_dependencies(u, d, e, other, add_reference);
2118
2119         return r;
2120 }
2121
2122 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2123         Unit *other;
2124         int r;
2125         _cleanup_free_ char *s = NULL;
2126
2127         assert(u);
2128         assert(name || path);
2129
2130         if (!(name = resolve_template(u, name, path, &s)))
2131                 return -ENOMEM;
2132
2133         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2134                 return r;
2135
2136         r = unit_add_dependency(other, d, u, add_reference);
2137
2138         return r;
2139 }
2140
2141 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2142         Unit *other;
2143         int r;
2144         _cleanup_free_ char *s = NULL;
2145
2146         assert(u);
2147         assert(name || path);
2148
2149         if (!(name = resolve_template(u, name, path, &s)))
2150                 return -ENOMEM;
2151
2152         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2153                 return r;
2154
2155         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2156                 return r;
2157
2158         return r;
2159 }
2160
2161 int set_unit_path(const char *p) {
2162         _cleanup_free_ char *c = NULL;
2163
2164         /* This is mostly for debug purposes */
2165         c = path_make_absolute_cwd(p);
2166         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2167                 return -errno;
2168
2169         return 0;
2170 }
2171
2172 char *unit_dbus_path(Unit *u) {
2173         assert(u);
2174
2175         if (!u->id)
2176                 return NULL;
2177
2178         return unit_dbus_path_from_name(u->id);
2179 }
2180
2181 char *unit_default_cgroup_path(Unit *u) {
2182         _cleanup_free_ char *escaped = NULL, *slice = NULL;
2183         int r;
2184
2185         assert(u);
2186
2187         if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2188                 return strdup(u->manager->cgroup_root);
2189
2190         if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2191                 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2192                 if (r < 0)
2193                         return NULL;
2194         }
2195
2196         escaped = cg_escape(u->id);
2197         if (!escaped)
2198                 return NULL;
2199
2200         if (slice)
2201                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2202         else
2203                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2204 }
2205
2206 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2207         _cleanup_free_ char *b = NULL;
2208         const char *slice_name;
2209         Unit *slice;
2210         int r;
2211
2212         assert(u);
2213         assert(c);
2214
2215         if (UNIT_ISSET(u->slice))
2216                 return 0;
2217
2218         if (u->instance) {
2219                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2220
2221                 /* Implicitly place all instantiated units in their
2222                  * own per-template slice */
2223
2224                 prefix = unit_name_to_prefix(u->id);
2225                 if (!prefix)
2226                         return -ENOMEM;
2227
2228                 /* The prefix is already escaped, but it might include
2229                  * "-" which has a special meaning for slice units,
2230                  * hence escape it here extra. */
2231                 escaped = strreplace(prefix, "-", "\\x2d");
2232                 if (!escaped)
2233                         return -ENOMEM;
2234
2235                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2236                         b = strjoin("system-", escaped, ".slice", NULL);
2237                 else
2238                         b = strappend(escaped, ".slice");
2239                 if (!b)
2240                         return -ENOMEM;
2241
2242                 slice_name = b;
2243         } else
2244                 slice_name =
2245                         u->manager->running_as == SYSTEMD_SYSTEM
2246                         ? SPECIAL_SYSTEM_SLICE
2247                         : SPECIAL_ROOT_SLICE;
2248
2249         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2250         if (r < 0)
2251                 return r;
2252
2253         unit_ref_set(&u->slice, slice);
2254         return 0;
2255 }
2256
2257 const char *unit_slice_name(Unit *u) {
2258         assert(u);
2259
2260         if (!UNIT_ISSET(u->slice))
2261                 return NULL;
2262
2263         return UNIT_DEREF(u->slice)->id;
2264 }
2265
2266 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2267         _cleanup_free_ char *t = NULL;
2268         int r;
2269
2270         assert(u);
2271         assert(type);
2272         assert(_found);
2273
2274         t = unit_name_change_suffix(u->id, type);
2275         if (!t)
2276                 return -ENOMEM;
2277
2278         assert(!unit_has_name(u, t));
2279
2280         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2281         assert(r < 0 || *_found != u);
2282         return r;
2283 }
2284
2285 int unit_watch_bus_name(Unit *u, const char *name) {
2286         assert(u);
2287         assert(name);
2288
2289         /* Watch a specific name on the bus. We only support one unit
2290          * watching each name for now. */
2291
2292         return hashmap_put(u->manager->watch_bus, name, u);
2293 }
2294
2295 void unit_unwatch_bus_name(Unit *u, const char *name) {
2296         assert(u);
2297         assert(name);
2298
2299         hashmap_remove_value(u->manager->watch_bus, name, u);
2300 }
2301
2302 bool unit_can_serialize(Unit *u) {
2303         assert(u);
2304
2305         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2306 }
2307
2308 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2309         int r;
2310
2311         assert(u);
2312         assert(f);
2313         assert(fds);
2314
2315         if (unit_can_serialize(u)) {
2316                 ExecRuntime *rt;
2317
2318                 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2319                 if (r < 0)
2320                         return r;
2321
2322                 rt = unit_get_exec_runtime(u);
2323                 if (rt) {
2324                         r = exec_runtime_serialize(rt, u, f, fds);
2325                         if (r < 0)
2326                                 return r;
2327                 }
2328         }
2329
2330         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2331         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2332         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2333         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2334         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2335
2336         if (dual_timestamp_is_set(&u->condition_timestamp))
2337                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2338
2339         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2340
2341         if (u->cgroup_path)
2342                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2343
2344         if (serialize_jobs) {
2345                 if (u->job) {
2346                         fprintf(f, "job\n");
2347                         job_serialize(u->job, f, fds);
2348                 }
2349
2350                 if (u->nop_job) {
2351                         fprintf(f, "job\n");
2352                         job_serialize(u->nop_job, f, fds);
2353                 }
2354         }
2355
2356         /* End marker */
2357         fputc('\n', f);
2358         return 0;
2359 }
2360
2361 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2362         va_list ap;
2363
2364         assert(u);
2365         assert(f);
2366         assert(key);
2367         assert(format);
2368
2369         fputs(key, f);
2370         fputc('=', f);
2371
2372         va_start(ap, format);
2373         vfprintf(f, format, ap);
2374         va_end(ap);
2375
2376         fputc('\n', f);
2377 }
2378
2379 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2380         assert(u);
2381         assert(f);
2382         assert(key);
2383         assert(value);
2384
2385         fprintf(f, "%s=%s\n", key, value);
2386 }
2387
2388 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2389         ExecRuntime **rt = NULL;
2390         size_t offset;
2391         int r;
2392
2393         assert(u);
2394         assert(f);
2395         assert(fds);
2396
2397         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2398         if (offset > 0)
2399                 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2400
2401         for (;;) {
2402                 char line[LINE_MAX], *l, *v;
2403                 size_t k;
2404
2405                 if (!fgets(line, sizeof(line), f)) {
2406                         if (feof(f))
2407                                 return 0;
2408                         return -errno;
2409                 }
2410
2411                 char_array_0(line);
2412                 l = strstrip(line);
2413
2414                 /* End marker */
2415                 if (l[0] == 0)
2416                         return 0;
2417
2418                 k = strcspn(l, "=");
2419
2420                 if (l[k] == '=') {
2421                         l[k] = 0;
2422                         v = l+k+1;
2423                 } else
2424                         v = l+k;
2425
2426                 if (streq(l, "job")) {
2427                         if (v[0] == '\0') {
2428                                 /* new-style serialized job */
2429                                 Job *j = job_new_raw(u);
2430                                 if (!j)
2431                                         return -ENOMEM;
2432
2433                                 r = job_deserialize(j, f, fds);
2434                                 if (r < 0) {
2435                                         job_free(j);
2436                                         return r;
2437                                 }
2438
2439                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2440                                 if (r < 0) {
2441                                         job_free(j);
2442                                         return r;
2443                                 }
2444
2445                                 r = job_install_deserialized(j);
2446                                 if (r < 0) {
2447                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2448                                         job_free(j);
2449                                         return r;
2450                                 }
2451
2452                                 if (j->state == JOB_RUNNING)
2453                                         u->manager->n_running_jobs++;
2454                         } else {
2455                                 /* legacy */
2456                                 JobType type = job_type_from_string(v);
2457                                 if (type < 0)
2458                                         log_debug("Failed to parse job type value %s", v);
2459                                 else
2460                                         u->deserialized_job = type;
2461                         }
2462                         continue;
2463                 } else if (streq(l, "inactive-exit-timestamp")) {
2464                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2465                         continue;
2466                 } else if (streq(l, "active-enter-timestamp")) {
2467                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2468                         continue;
2469                 } else if (streq(l, "active-exit-timestamp")) {
2470                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2471                         continue;
2472                 } else if (streq(l, "inactive-enter-timestamp")) {
2473                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2474                         continue;
2475                 } else if (streq(l, "condition-timestamp")) {
2476                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2477                         continue;
2478                 } else if (streq(l, "condition-result")) {
2479                         int b;
2480
2481                         b = parse_boolean(v);
2482                         if (b < 0)
2483                                 log_debug("Failed to parse condition result value %s", v);
2484                         else
2485                                 u->condition_result = b;
2486
2487                         continue;
2488
2489                 } else if (streq(l, "transient")) {
2490                         int b;
2491
2492                         b = parse_boolean(v);
2493                         if (b < 0)
2494                                 log_debug("Failed to parse transient bool %s", v);
2495                         else
2496                                 u->transient = b;
2497
2498                         continue;
2499                 } else if (streq(l, "cgroup")) {
2500                         char *s;
2501
2502                         s = strdup(v);
2503                         if (!s)
2504                                 return -ENOMEM;
2505
2506                         if (u->cgroup_path) {
2507                                 void *p;
2508
2509                                 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2510                                 log_info("Removing cgroup_path %s from hashmap (%p)",
2511                                          u->cgroup_path, p);
2512                                 free(u->cgroup_path);
2513                         }
2514
2515                         u->cgroup_path = s;
2516                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2517
2518                         continue;
2519                 }
2520
2521                 if (unit_can_serialize(u)) {
2522                         if (rt) {
2523                                 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2524                                 if (r < 0)
2525                                         return r;
2526                                 if (r > 0)
2527                                         continue;
2528                         }
2529
2530                         r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2531                         if (r < 0)
2532                                 return r;
2533                 }
2534         }
2535 }
2536
2537 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2538         Unit *device;
2539         _cleanup_free_ char *e = NULL;
2540         int r;
2541
2542         assert(u);
2543
2544         if (!what)
2545                 return 0;
2546
2547         /* Adds in links to the device node that this unit is based on */
2548
2549         if (!is_device_path(what))
2550                 return 0;
2551
2552         e = unit_name_from_path(what, ".device");
2553         if (!e)
2554                 return -ENOMEM;
2555
2556         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2557
2558         if (r < 0)
2559                 return r;
2560
2561         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2562         if (r < 0)
2563                 return r;
2564
2565         if (wants) {
2566                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2567                 if (r < 0)
2568                         return r;
2569         }
2570
2571         return 0;
2572 }
2573
2574 int unit_coldplug(Unit *u) {
2575         int r;
2576
2577         assert(u);
2578
2579         if (UNIT_VTABLE(u)->coldplug)
2580                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2581                         return r;
2582
2583         if (u->job) {
2584                 r = job_coldplug(u->job);
2585                 if (r < 0)
2586                         return r;
2587         } else if (u->deserialized_job >= 0) {
2588                 /* legacy */
2589                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2590                 if (r < 0)
2591                         return r;
2592
2593                 u->deserialized_job = _JOB_TYPE_INVALID;
2594         }
2595
2596         return 0;
2597 }
2598
2599 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2600         DISABLE_WARNING_FORMAT_NONLITERAL;
2601         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2602         REENABLE_WARNING;
2603 }
2604
2605 bool unit_need_daemon_reload(Unit *u) {
2606         _cleanup_strv_free_ char **t = NULL;
2607         char **path;
2608         struct stat st;
2609         unsigned loaded_cnt, current_cnt;
2610
2611         assert(u);
2612
2613         if (u->fragment_path) {
2614                 zero(st);
2615                 if (stat(u->fragment_path, &st) < 0)
2616                         /* What, cannot access this anymore? */
2617                         return true;
2618
2619                 if (u->fragment_mtime > 0 &&
2620                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2621                         return true;
2622         }
2623
2624         if (u->source_path) {
2625                 zero(st);
2626                 if (stat(u->source_path, &st) < 0)
2627                         return true;
2628
2629                 if (u->source_mtime > 0 &&
2630                     timespec_load(&st.st_mtim) != u->source_mtime)
2631                         return true;
2632         }
2633
2634         t = unit_find_dropin_paths(u);
2635         loaded_cnt = strv_length(t);
2636         current_cnt = strv_length(u->dropin_paths);
2637
2638         if (loaded_cnt == current_cnt) {
2639                 if (loaded_cnt == 0)
2640                         return false;
2641
2642                 if (strv_overlap(u->dropin_paths, t)) {
2643                         STRV_FOREACH(path, u->dropin_paths) {
2644                                 zero(st);
2645                                 if (stat(*path, &st) < 0)
2646                                         return true;
2647
2648                                 if (u->dropin_mtime > 0 &&
2649                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2650                                         return true;
2651                         }
2652
2653                         return false;
2654                 } else
2655                         return true;
2656         } else
2657                 return true;
2658 }
2659
2660 void unit_reset_failed(Unit *u) {
2661         assert(u);
2662
2663         if (UNIT_VTABLE(u)->reset_failed)
2664                 UNIT_VTABLE(u)->reset_failed(u);
2665 }
2666
2667 Unit *unit_following(Unit *u) {
2668         assert(u);
2669
2670         if (UNIT_VTABLE(u)->following)
2671                 return UNIT_VTABLE(u)->following(u);
2672
2673         return NULL;
2674 }
2675
2676 bool unit_stop_pending(Unit *u) {
2677         assert(u);
2678
2679         /* This call does check the current state of the unit. It's
2680          * hence useful to be called from state change calls of the
2681          * unit itself, where the state isn't updated yet. This is
2682          * different from unit_inactive_or_pending() which checks both
2683          * the current state and for a queued job. */
2684
2685         return u->job && u->job->type == JOB_STOP;
2686 }
2687
2688 bool unit_inactive_or_pending(Unit *u) {
2689         assert(u);
2690
2691         /* Returns true if the unit is inactive or going down */
2692
2693         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2694                 return true;
2695
2696         if (unit_stop_pending(u))
2697                 return true;
2698
2699         return false;
2700 }
2701
2702 bool unit_active_or_pending(Unit *u) {
2703         assert(u);
2704
2705         /* Returns true if the unit is active or going up */
2706
2707         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2708                 return true;
2709
2710         if (u->job &&
2711             (u->job->type == JOB_START ||
2712              u->job->type == JOB_RELOAD_OR_START ||
2713              u->job->type == JOB_RESTART))
2714                 return true;
2715
2716         return false;
2717 }
2718
2719 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2720         assert(u);
2721         assert(w >= 0 && w < _KILL_WHO_MAX);
2722         assert(signo > 0);
2723         assert(signo < _NSIG);
2724
2725         if (!UNIT_VTABLE(u)->kill)
2726                 return -ENOTSUP;
2727
2728         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2729 }
2730
2731 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2732         Set *pid_set;
2733         int r;
2734
2735         pid_set = set_new(trivial_hash_func, trivial_compare_func);
2736         if (!pid_set)
2737                 return NULL;
2738
2739         /* Exclude the main/control pids from being killed via the cgroup */
2740         if (main_pid > 0) {
2741                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2742                 if (r < 0)
2743                         goto fail;
2744         }
2745
2746         if (control_pid > 0) {
2747                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2748                 if (r < 0)
2749                         goto fail;
2750         }
2751
2752         return pid_set;
2753
2754 fail:
2755         set_free(pid_set);
2756         return NULL;
2757 }
2758
2759 int unit_kill_common(
2760                 Unit *u,
2761                 KillWho who,
2762                 int signo,
2763                 pid_t main_pid,
2764                 pid_t control_pid,
2765                 sd_bus_error *error) {
2766
2767         int r = 0;
2768
2769         if (who == KILL_MAIN && main_pid <= 0) {
2770                 if (main_pid < 0)
2771                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2772                 else
2773                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2774                 return -ESRCH;
2775         }
2776
2777         if (who == KILL_CONTROL && control_pid <= 0) {
2778                 if (control_pid < 0)
2779                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2780                 else
2781                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2782                 return -ESRCH;
2783         }
2784
2785         if (who == KILL_CONTROL || who == KILL_ALL)
2786                 if (control_pid > 0)
2787                         if (kill(control_pid, signo) < 0)
2788                                 r = -errno;
2789
2790         if (who == KILL_MAIN || who == KILL_ALL)
2791                 if (main_pid > 0)
2792                         if (kill(main_pid, signo) < 0)
2793                                 r = -errno;
2794
2795         if (who == KILL_ALL && u->cgroup_path) {
2796                 _cleanup_set_free_ Set *pid_set = NULL;
2797                 int q;
2798
2799                 /* Exclude the main/control pids from being killed via the cgroup */
2800                 pid_set = unit_pid_set(main_pid, control_pid);
2801                 if (!pid_set)
2802                         return -ENOMEM;
2803
2804                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2805                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2806                         r = q;
2807         }
2808
2809         return r;
2810 }
2811
2812 int unit_following_set(Unit *u, Set **s) {
2813         assert(u);
2814         assert(s);
2815
2816         if (UNIT_VTABLE(u)->following_set)
2817                 return UNIT_VTABLE(u)->following_set(u, s);
2818
2819         *s = NULL;
2820         return 0;
2821 }
2822
2823 UnitFileState unit_get_unit_file_state(Unit *u) {
2824         assert(u);
2825
2826         if (u->unit_file_state < 0 && u->fragment_path)
2827                 u->unit_file_state = unit_file_get_state(
2828                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2829                                 NULL, basename(u->fragment_path));
2830
2831         return u->unit_file_state;
2832 }
2833
2834 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2835         assert(ref);
2836         assert(u);
2837
2838         if (ref->unit)
2839                 unit_ref_unset(ref);
2840
2841         ref->unit = u;
2842         LIST_PREPEND(refs, u->refs, ref);
2843         return u;
2844 }
2845
2846 void unit_ref_unset(UnitRef *ref) {
2847         assert(ref);
2848
2849         if (!ref->unit)
2850                 return;
2851
2852         LIST_REMOVE(refs, ref->unit->refs, ref);
2853         ref->unit = NULL;
2854 }
2855
2856 int unit_patch_contexts(Unit *u) {
2857         CGroupContext *cc;
2858         ExecContext *ec;
2859         unsigned i;
2860         int r;
2861
2862         assert(u);
2863
2864         /* Patch in the manager defaults into the exec and cgroup
2865          * contexts, _after_ the rest of the settings have been
2866          * initialized */
2867
2868         ec = unit_get_exec_context(u);
2869         if (ec) {
2870                 /* This only copies in the ones that need memory */
2871                 for (i = 0; i < _RLIMIT_MAX; i++)
2872                         if (u->manager->rlimit[i] && !ec->rlimit[i]) {
2873                                 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2874                                 if (!ec->rlimit[i])
2875                                         return -ENOMEM;
2876                         }
2877
2878                 if (u->manager->running_as == SYSTEMD_USER &&
2879                     !ec->working_directory) {
2880
2881                         r = get_home_dir(&ec->working_directory);
2882                         if (r < 0)
2883                                 return r;
2884                 }
2885
2886                 if (u->manager->running_as == SYSTEMD_USER &&
2887                     (ec->syscall_whitelist ||
2888                      !set_isempty(ec->syscall_filter) ||
2889                      !set_isempty(ec->syscall_archs) ||
2890                      ec->address_families_whitelist ||
2891                      !set_isempty(ec->address_families)))
2892                         ec->no_new_privileges = true;
2893
2894                 if (ec->private_devices)
2895                         ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
2896         }
2897
2898         cc = unit_get_cgroup_context(u);
2899         if (cc) {
2900
2901                 if (ec &&
2902                     ec->private_devices &&
2903                     cc->device_policy == CGROUP_AUTO)
2904                         cc->device_policy = CGROUP_CLOSED;
2905         }
2906
2907         return 0;
2908 }
2909
2910 ExecContext *unit_get_exec_context(Unit *u) {
2911         size_t offset;
2912         assert(u);
2913
2914         if (u->type < 0)
2915                 return NULL;
2916
2917         offset = UNIT_VTABLE(u)->exec_context_offset;
2918         if (offset <= 0)
2919                 return NULL;
2920
2921         return (ExecContext*) ((uint8_t*) u + offset);
2922 }
2923
2924 KillContext *unit_get_kill_context(Unit *u) {
2925         size_t offset;
2926         assert(u);
2927
2928         if (u->type < 0)
2929                 return NULL;
2930
2931         offset = UNIT_VTABLE(u)->kill_context_offset;
2932         if (offset <= 0)
2933                 return NULL;
2934
2935         return (KillContext*) ((uint8_t*) u + offset);
2936 }
2937
2938 CGroupContext *unit_get_cgroup_context(Unit *u) {
2939         size_t offset;
2940
2941         if (u->type < 0)
2942                 return NULL;
2943
2944         offset = UNIT_VTABLE(u)->cgroup_context_offset;
2945         if (offset <= 0)
2946                 return NULL;
2947
2948         return (CGroupContext*) ((uint8_t*) u + offset);
2949 }
2950
2951 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2952         size_t offset;
2953
2954         if (u->type < 0)
2955                 return NULL;
2956
2957         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2958         if (offset <= 0)
2959                 return NULL;
2960
2961         return *(ExecRuntime**) ((uint8_t*) u + offset);
2962 }
2963
2964 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2965         _cleanup_free_ char *b = NULL;
2966         char *p, *q;
2967         int r;
2968
2969         assert(u);
2970         assert(name);
2971         assert(_p);
2972         assert(_q);
2973
2974         b = xescape(name, "/.");
2975         if (!b)
2976                 return -ENOMEM;
2977
2978         if (!filename_is_safe(b))
2979                 return -EINVAL;
2980
2981         if (u->manager->running_as == SYSTEMD_USER) {
2982                 _cleanup_free_ char *c = NULL;
2983
2984                 r = user_config_home(&c);
2985                 if (r < 0)
2986                         return r;
2987                 if (r == 0)
2988                         return -ENOENT;
2989
2990                 p = strjoin(c, "/", u->id, ".d", NULL);
2991         } else if (mode == UNIT_PERSISTENT && !u->transient)
2992                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2993         else
2994                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2995         if (!p)
2996                 return -ENOMEM;
2997
2998         q = strjoin(p, "/90-", b, ".conf", NULL);
2999         if (!q) {
3000                 free(p);
3001                 return -ENOMEM;
3002         }
3003
3004         *_p = p;
3005         *_q = q;
3006         return 0;
3007 }
3008
3009 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3010         _cleanup_free_ char *p = NULL, *q = NULL;
3011         int r;
3012
3013         assert(u);
3014         assert(name);
3015         assert(data);
3016
3017         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3018                 return 0;
3019
3020         r = drop_in_file(u, mode, name, &p, &q);
3021         if (r < 0)
3022                 return r;
3023
3024         mkdir_p(p, 0755);
3025         return write_string_file_atomic_label(q, data);
3026 }
3027
3028 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3029         _cleanup_free_ char *p = NULL;
3030         va_list ap;
3031         int r;
3032
3033         assert(u);
3034         assert(name);
3035         assert(format);
3036
3037         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3038                 return 0;
3039
3040         va_start(ap, format);
3041         r = vasprintf(&p, format, ap);
3042         va_end(ap);
3043
3044         if (r < 0)
3045                 return -ENOMEM;
3046
3047         return unit_write_drop_in(u, mode, name, p);
3048 }
3049
3050 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3051         _cleanup_free_ char *ndata = NULL;
3052
3053         assert(u);
3054         assert(name);
3055         assert(data);
3056
3057         if (!UNIT_VTABLE(u)->private_section)
3058                 return -EINVAL;
3059
3060         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3061                 return 0;
3062
3063         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3064         if (!ndata)
3065                 return -ENOMEM;
3066
3067         return unit_write_drop_in(u, mode, name, ndata);
3068 }
3069
3070 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3071         _cleanup_free_ char *p = NULL;
3072         va_list ap;
3073         int r;
3074
3075         assert(u);
3076         assert(name);
3077         assert(format);
3078
3079         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3080                 return 0;
3081
3082         va_start(ap, format);
3083         r = vasprintf(&p, format, ap);
3084         va_end(ap);
3085
3086         if (r < 0)
3087                 return -ENOMEM;
3088
3089         return unit_write_drop_in_private(u, mode, name, p);
3090 }
3091
3092 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3093         _cleanup_free_ char *p = NULL, *q = NULL;
3094         int r;
3095
3096         assert(u);
3097
3098         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3099                 return 0;
3100
3101         r = drop_in_file(u, mode, name, &p, &q);
3102         if (r < 0)
3103                 return r;
3104
3105         if (unlink(q) < 0)
3106                 r = errno == ENOENT ? 0 : -errno;
3107         else
3108                 r = 1;
3109
3110         rmdir(p);
3111         return r;
3112 }
3113
3114 int unit_make_transient(Unit *u) {
3115         int r;
3116
3117         assert(u);
3118
3119         u->load_state = UNIT_STUB;
3120         u->load_error = 0;
3121         u->transient = true;
3122
3123         free(u->fragment_path);
3124         u->fragment_path = NULL;
3125
3126         if (u->manager->running_as == SYSTEMD_USER) {
3127                 _cleanup_free_ char *c = NULL;
3128
3129                 r = user_config_home(&c);
3130                 if (r < 0)
3131                         return r;
3132                 if (r == 0)
3133                         return -ENOENT;
3134
3135                 u->fragment_path = strjoin(c, "/", u->id, NULL);
3136                 if (!u->fragment_path)
3137                         return -ENOMEM;
3138
3139                 mkdir_p(c, 0755);
3140         } else {
3141                 u->fragment_path = strappend("/run/systemd/system/", u->id);
3142                 if (!u->fragment_path)
3143                         return -ENOMEM;
3144
3145                 mkdir_p("/run/systemd/system", 0755);
3146         }
3147
3148         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3149 }
3150
3151 int unit_kill_context(
3152                 Unit *u,
3153                 KillContext *c,
3154                 bool sigkill,
3155                 pid_t main_pid,
3156                 pid_t control_pid,
3157                 bool main_pid_alien) {
3158
3159         int sig, wait_for_exit = false, r;
3160
3161         assert(u);
3162         assert(c);
3163
3164         if (c->kill_mode == KILL_NONE)
3165                 return 0;
3166
3167         sig = sigkill ? SIGKILL : c->kill_signal;
3168
3169         if (main_pid > 0) {
3170                 r = kill_and_sigcont(main_pid, sig);
3171
3172                 if (r < 0 && r != -ESRCH) {
3173                         _cleanup_free_ char *comm = NULL;
3174                         get_process_comm(main_pid, &comm);
3175
3176                         log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3177                 } else {
3178                         if (!main_pid_alien)
3179                                 wait_for_exit = true;
3180
3181                         if (c->send_sighup && !sigkill)
3182                                 kill(main_pid, SIGHUP);
3183                 }
3184         }
3185
3186         if (control_pid > 0) {
3187                 r = kill_and_sigcont(control_pid, sig);
3188
3189                 if (r < 0 && r != -ESRCH) {
3190                         _cleanup_free_ char *comm = NULL;
3191                         get_process_comm(control_pid, &comm);
3192
3193                         log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3194                 } else {
3195                         wait_for_exit = true;
3196
3197                         if (c->send_sighup && !sigkill)
3198                                 kill(control_pid, SIGHUP);
3199                 }
3200         }
3201
3202         if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3203                 _cleanup_set_free_ Set *pid_set = NULL;
3204
3205                 /* Exclude the main/control pids from being killed via the cgroup */
3206                 pid_set = unit_pid_set(main_pid, control_pid);
3207                 if (!pid_set)
3208                         return -ENOMEM;
3209
3210                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3211                 if (r < 0) {
3212                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3213                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3214                 } else if (r > 0) {
3215
3216                         /* FIXME: For now, we will not wait for the
3217                          * cgroup members to die, simply because
3218                          * cgroup notification is unreliable. It
3219                          * doesn't work at all in containers, and
3220                          * outside of containers it can be confused
3221                          * easily by leaving directories in the
3222                          * cgroup. */
3223
3224                         /* wait_for_exit = true; */
3225
3226                         if (c->send_sighup && !sigkill) {
3227                                 set_free(pid_set);
3228
3229                                 pid_set = unit_pid_set(main_pid, control_pid);
3230                                 if (!pid_set)
3231                                         return -ENOMEM;
3232
3233                                 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3234                         }
3235                 }
3236         }
3237
3238         return wait_for_exit;
3239 }
3240
3241 int unit_require_mounts_for(Unit *u, const char *path) {
3242         char prefix[strlen(path) + 1], *p;
3243         int r;
3244
3245         assert(u);
3246         assert(path);
3247
3248         /* Registers a unit for requiring a certain path and all its
3249          * prefixes. We keep a simple array of these paths in the
3250          * unit, since its usually short. However, we build a prefix
3251          * table for all possible prefixes so that new appearing mount
3252          * units can easily determine which units to make themselves a
3253          * dependency of. */
3254
3255         if (!path_is_absolute(path))
3256                 return -EINVAL;
3257
3258         p = strdup(path);
3259         if (!p)
3260                 return -ENOMEM;
3261
3262         path_kill_slashes(p);
3263
3264         if (!path_is_safe(p)) {
3265                 free(p);
3266                 return -EPERM;
3267         }
3268
3269         if (strv_contains(u->requires_mounts_for, p)) {
3270                 free(p);
3271                 return 0;
3272         }
3273
3274         r = strv_consume(&u->requires_mounts_for, p);
3275         if (r < 0)
3276                 return r;
3277
3278         PATH_FOREACH_PREFIX_MORE(prefix, p) {
3279                 Set *x;
3280
3281                 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3282                 if (!x) {
3283                         char *q;
3284
3285                         if (!u->manager->units_requiring_mounts_for) {
3286                                 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3287                                 if (!u->manager->units_requiring_mounts_for)
3288                                         return -ENOMEM;
3289                         }
3290
3291                         q = strdup(prefix);
3292                         if (!q)
3293                                 return -ENOMEM;
3294
3295                         x = set_new(NULL, NULL);
3296                         if (!x) {
3297                                 free(q);
3298                                 return -ENOMEM;
3299                         }
3300
3301                         r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3302                         if (r < 0) {
3303                                 free(q);
3304                                 set_free(x);
3305                                 return r;
3306                         }
3307                 }
3308
3309                 r = set_put(x, u);
3310                 if (r < 0)
3311                         return r;
3312         }
3313
3314         return 0;
3315 }
3316
3317 int unit_setup_exec_runtime(Unit *u) {
3318         ExecRuntime **rt;
3319         size_t offset;
3320         Iterator i;
3321         Unit *other;
3322
3323         offset = UNIT_VTABLE(u)->exec_runtime_offset;
3324         assert(offset > 0);
3325
3326         /* Check if ther already is an ExecRuntime for this unit? */
3327         rt = (ExecRuntime**) ((uint8_t*) u + offset);
3328         if (*rt)
3329                 return 0;
3330
3331         /* Try to get it from somebody else */
3332         SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3333
3334                 *rt = unit_get_exec_runtime(other);
3335                 if (*rt) {
3336                         exec_runtime_ref(*rt);
3337                         return 0;
3338                 }
3339         }
3340
3341         return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3342 }
3343
3344 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3345         [UNIT_ACTIVE] = "active",
3346         [UNIT_RELOADING] = "reloading",
3347         [UNIT_INACTIVE] = "inactive",
3348         [UNIT_FAILED] = "failed",
3349         [UNIT_ACTIVATING] = "activating",
3350         [UNIT_DEACTIVATING] = "deactivating"
3351 };
3352
3353 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3354
3355 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3356         [UNIT_REQUIRES] = "Requires",
3357         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3358         [UNIT_REQUISITE] = "Requisite",
3359         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3360         [UNIT_WANTS] = "Wants",
3361         [UNIT_BINDS_TO] = "BindsTo",
3362         [UNIT_PART_OF] = "PartOf",
3363         [UNIT_REQUIRED_BY] = "RequiredBy",
3364         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3365         [UNIT_WANTED_BY] = "WantedBy",
3366         [UNIT_BOUND_BY] = "BoundBy",
3367         [UNIT_CONSISTS_OF] = "ConsistsOf",
3368         [UNIT_CONFLICTS] = "Conflicts",
3369         [UNIT_CONFLICTED_BY] = "ConflictedBy",
3370         [UNIT_BEFORE] = "Before",
3371         [UNIT_AFTER] = "After",
3372         [UNIT_ON_FAILURE] = "OnFailure",
3373         [UNIT_TRIGGERS] = "Triggers",
3374         [UNIT_TRIGGERED_BY] = "TriggeredBy",
3375         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3376         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3377         [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3378         [UNIT_REFERENCES] = "References",
3379         [UNIT_REFERENCED_BY] = "ReferencedBy",
3380 };
3381
3382 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);