src/core/unit.c

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