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