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