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