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