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