src/core/unit.c

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