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