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