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_realized_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_target_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         unsigned k;
 962         int r = 0;
 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         return r;
 974 }
 975
 976 static int unit_add_slice_dependencies(Unit *u) {
 977         assert(u);
 978
 979         if (!unit_get_cgroup_context(u))
 980                 return 0;
 981
 982         if (UNIT_ISSET(u->slice))
 983                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
 984
 985         return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
 986 }
 987
 988 static int unit_add_mount_dependencies(Unit *u) {
 989         char **i;
 990         int r;
 991
 992         assert(u);
 993
 994         STRV_FOREACH(i, u->requires_mounts_for) {
 995                 char prefix[strlen(*i) + 1];
 996
 997                 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
 998                         Unit *m;
 999
1000                         r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1001                         if (r < 0)
1002                                 return r;
1003                         if (r == 0)
1004                                 continue;
1005                         if (m == u)
1006                                 continue;
1007
1008                         if (m->load_state != UNIT_LOADED)
1009                                 continue;
1010
1011                         r = unit_add_dependency(u, UNIT_AFTER, m, true);
1012                         if (r < 0)
1013                                 return r;
1014
1015                         if (m->fragment_path) {
1016                                 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1017                                 if (r < 0)
1018                                         return r;
1019                         }
1020                 }
1021         }
1022
1023         return 0;
1024 }
1025
1026 int unit_load(Unit *u) {
1027         int r;
1028
1029         assert(u);
1030
1031         if (u->in_load_queue) {
1032                 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1033                 u->in_load_queue = false;
1034         }
1035
1036         if (u->type == _UNIT_TYPE_INVALID)
1037                 return -EINVAL;
1038
1039         if (u->load_state != UNIT_STUB)
1040                 return 0;
1041
1042         if (UNIT_VTABLE(u)->load) {
1043                 r = UNIT_VTABLE(u)->load(u);
1044                 if (r < 0)
1045                         goto fail;
1046         }
1047
1048         if (u->load_state == UNIT_STUB) {
1049                 r = -ENOENT;
1050                 goto fail;
1051         }
1052
1053         if (u->load_state == UNIT_LOADED) {
1054
1055                 r = unit_add_target_dependencies(u);
1056                 if (r < 0)
1057                         goto fail;
1058
1059                 r = unit_add_slice_dependencies(u);
1060                 if (r < 0)
1061                         goto fail;
1062
1063                 r = unit_add_mount_dependencies(u);
1064                 if (r < 0)
1065                         goto fail;
1066
1067                 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1068                         log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1069                         r = -EINVAL;
1070                         goto fail;
1071                 }
1072
1073                 unit_update_cgroup_members_masks(u);
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 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1144         const char *format;
1145
1146         assert(u);
1147
1148         /* We only print status messages for selected units on
1149          * selected operations. */
1150
1151         format = unit_get_status_message_format(u, t);
1152         if (!format)
1153                 return;
1154
1155         DISABLE_WARNING_FORMAT_NONLITERAL;
1156         unit_status_printf(u, "", format);
1157         REENABLE_WARNING;
1158 }
1159
1160 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1161         const char *format;
1162         char buf[LINE_MAX];
1163         sd_id128_t mid;
1164
1165         assert(u);
1166
1167         if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1168                 return;
1169
1170         if (log_on_console())
1171                 return;
1172
1173         /* We log status messages for all units and all operations. */
1174
1175         format = unit_get_status_message_format_try_harder(u, t);
1176         if (!format)
1177                 return;
1178
1179         DISABLE_WARNING_FORMAT_NONLITERAL;
1180         snprintf(buf, sizeof(buf), format, unit_description(u));
1181         char_array_0(buf);
1182         REENABLE_WARNING;
1183
1184         mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1185               t == JOB_STOP  ? SD_MESSAGE_UNIT_STOPPING :
1186                                SD_MESSAGE_UNIT_RELOADING;
1187
1188         log_struct_unit(LOG_INFO,
1189                         u->id,
1190                         MESSAGE_ID(mid),
1191                         "MESSAGE=%s", buf,
1192                         NULL);
1193 }
1194
1195 /* Errors:
1196  *         -EBADR:     This unit type does not support starting.
1197  *         -EALREADY:  Unit is already started.
1198  *         -EAGAIN:    An operation is already in progress. Retry later.
1199  *         -ECANCELED: Too many requests for now.
1200  */
1201 int unit_start(Unit *u) {
1202         UnitActiveState state;
1203         Unit *following;
1204
1205         assert(u);
1206
1207         if (u->load_state != UNIT_LOADED)
1208                 return -EINVAL;
1209
1210         /* If this is already started, then this will succeed. Note
1211          * that this will even succeed if this unit is not startable
1212          * by the user. This is relied on to detect when we need to
1213          * wait for units and when waiting is finished. */
1214         state = unit_active_state(u);
1215         if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1216                 return -EALREADY;
1217
1218         /* If the conditions failed, don't do anything at all. If we
1219          * already are activating this call might still be useful to
1220          * speed up activation in case there is some hold-off time,
1221          * but we don't want to recheck the condition in that case. */
1222         if (state != UNIT_ACTIVATING &&
1223             !unit_condition_test(u)) {
1224                 log_debug_unit(u->id, "Starting of %s requested but condition failed. Ignoring.", u->id);
1225                 return -EALREADY;
1226         }
1227
1228         /* Forward to the main object, if we aren't it. */
1229         following = unit_following(u);
1230         if (following) {
1231                 log_debug_unit(u->id, "Redirecting start request from %s to %s.",
1232                                u->id, following->id);
1233                 return unit_start(following);
1234         }
1235
1236         unit_status_log_starting_stopping_reloading(u, JOB_START);
1237         unit_status_print_starting_stopping(u, JOB_START);
1238
1239         /* If it is stopped, but we cannot start it, then fail */
1240         if (!UNIT_VTABLE(u)->start)
1241                 return -EBADR;
1242
1243         /* We don't suppress calls to ->start() here when we are
1244          * already starting, to allow this request to be used as a
1245          * "hurry up" call, for example when the unit is in some "auto
1246          * restart" state where it waits for a holdoff timer to elapse
1247          * before it will start again. */
1248
1249         unit_add_to_dbus_queue(u);
1250
1251         return UNIT_VTABLE(u)->start(u);
1252 }
1253
1254 bool unit_can_start(Unit *u) {
1255         assert(u);
1256
1257         return !!UNIT_VTABLE(u)->start;
1258 }
1259
1260 bool unit_can_isolate(Unit *u) {
1261         assert(u);
1262
1263         return unit_can_start(u) &&
1264                 u->allow_isolate;
1265 }
1266
1267 /* Errors:
1268  *         -EBADR:    This unit type does not support stopping.
1269  *         -EALREADY: Unit is already stopped.
1270  *         -EAGAIN:   An operation is already in progress. Retry later.
1271  */
1272 int unit_stop(Unit *u) {
1273         UnitActiveState state;
1274         Unit *following;
1275
1276         assert(u);
1277
1278         state = unit_active_state(u);
1279         if (UNIT_IS_INACTIVE_OR_FAILED(state))
1280                 return -EALREADY;
1281
1282         if ((following = unit_following(u))) {
1283                 log_debug_unit(u->id, "Redirecting stop request from %s to %s.",
1284                                u->id, following->id);
1285                 return unit_stop(following);
1286         }
1287
1288         unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1289         unit_status_print_starting_stopping(u, JOB_STOP);
1290
1291         if (!UNIT_VTABLE(u)->stop)
1292                 return -EBADR;
1293
1294         unit_add_to_dbus_queue(u);
1295
1296         return UNIT_VTABLE(u)->stop(u);
1297 }
1298
1299 /* Errors:
1300  *         -EBADR:    This unit type does not support reloading.
1301  *         -ENOEXEC:  Unit is not started.
1302  *         -EAGAIN:   An operation is already in progress. Retry later.
1303  */
1304 int unit_reload(Unit *u) {
1305         UnitActiveState state;
1306         Unit *following;
1307
1308         assert(u);
1309
1310         if (u->load_state != UNIT_LOADED)
1311                 return -EINVAL;
1312
1313         if (!unit_can_reload(u))
1314                 return -EBADR;
1315
1316         state = unit_active_state(u);
1317         if (state == UNIT_RELOADING)
1318                 return -EALREADY;
1319
1320         if (state != UNIT_ACTIVE) {
1321                 log_warning_unit(u->id, "Unit %s cannot be reloaded because it is inactive.",
1322                                  u->id);
1323                 return -ENOEXEC;
1324         }
1325
1326         following = unit_following(u);
1327         if (following) {
1328                 log_debug_unit(u->id, "Redirecting reload request from %s to %s.",
1329                                u->id, following->id);
1330                 return unit_reload(following);
1331         }
1332
1333         unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1334
1335         unit_add_to_dbus_queue(u);
1336         return UNIT_VTABLE(u)->reload(u);
1337 }
1338
1339 bool unit_can_reload(Unit *u) {
1340         assert(u);
1341
1342         if (!UNIT_VTABLE(u)->reload)
1343                 return false;
1344
1345         if (!UNIT_VTABLE(u)->can_reload)
1346                 return true;
1347
1348         return UNIT_VTABLE(u)->can_reload(u);
1349 }
1350
1351 static void unit_check_unneeded(Unit *u) {
1352         Iterator i;
1353         Unit *other;
1354
1355         assert(u);
1356
1357         /* If this service shall be shut down when unneeded then do
1358          * so. */
1359
1360         if (!u->stop_when_unneeded)
1361                 return;
1362
1363         if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1364                 return;
1365
1366         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1367                 if (unit_active_or_pending(other))
1368                         return;
1369
1370         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1371                 if (unit_active_or_pending(other))
1372                         return;
1373
1374         SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1375                 if (unit_active_or_pending(other))
1376                         return;
1377
1378         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1379                 if (unit_active_or_pending(other))
1380                         return;
1381
1382         log_info_unit(u->id, "Service %s is not needed anymore. Stopping.", u->id);
1383
1384         /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1385         manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1386 }
1387
1388 static void retroactively_start_dependencies(Unit *u) {
1389         Iterator i;
1390         Unit *other;
1391
1392         assert(u);
1393         assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1394
1395         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1396                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1397                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1398                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1399
1400         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1401                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1402                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1403                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1404
1405         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1406                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1407                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1408                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1409
1410         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1411                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1412                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1413                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1414
1415         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1416                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1417                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1418
1419         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1420                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1421                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1422 }
1423
1424 static void retroactively_stop_dependencies(Unit *u) {
1425         Iterator i;
1426         Unit *other;
1427
1428         assert(u);
1429         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1430
1431         /* Pull down units which are bound to us recursively if enabled */
1432         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1433                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1434                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1435 }
1436
1437 static void check_unneeded_dependencies(Unit *u) {
1438         Iterator i;
1439         Unit *other;
1440
1441         assert(u);
1442         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1443
1444         /* Garbage collect services that might not be needed anymore, if enabled */
1445         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1446                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1447                         unit_check_unneeded(other);
1448         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1449                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1450                         unit_check_unneeded(other);
1451         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1452                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1453                         unit_check_unneeded(other);
1454         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1455                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1456                         unit_check_unneeded(other);
1457         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1458                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1459                         unit_check_unneeded(other);
1460         SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1461                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1462                         unit_check_unneeded(other);
1463 }
1464
1465 void unit_start_on_failure(Unit *u) {
1466         Unit *other;
1467         Iterator i;
1468
1469         assert(u);
1470
1471         if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1472                 return;
1473
1474         log_info_unit(u->id, "Triggering OnFailure= dependencies of %s.", u->id);
1475
1476         SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1477                 int r;
1478
1479                 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1480                 if (r < 0)
1481                         log_error_unit(u->id, "Failed to enqueue OnFailure= job: %s", strerror(-r));
1482         }
1483 }
1484
1485 void unit_trigger_notify(Unit *u) {
1486         Unit *other;
1487         Iterator i;
1488
1489         assert(u);
1490
1491         SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1492                 if (UNIT_VTABLE(other)->trigger_notify)
1493                         UNIT_VTABLE(other)->trigger_notify(other, u);
1494 }
1495
1496 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1497         Manager *m;
1498         bool unexpected;
1499
1500         assert(u);
1501         assert(os < _UNIT_ACTIVE_STATE_MAX);
1502         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1503
1504         /* Note that this is called for all low-level state changes,
1505          * even if they might map to the same high-level
1506          * UnitActiveState! That means that ns == os is OK an expected
1507          * behavior here. For example: if a mount point is remounted
1508          * this function will be called too! */
1509
1510         m = u->manager;
1511
1512         if (m->n_reloading <= 0) {
1513                 dual_timestamp ts;
1514
1515                 dual_timestamp_get(&ts);
1516
1517                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1518                         u->inactive_exit_timestamp = ts;
1519                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1520                         u->inactive_enter_timestamp = ts;
1521
1522                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1523                         u->active_enter_timestamp = ts;
1524                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1525                         u->active_exit_timestamp = ts;
1526         }
1527
1528         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1529                 unit_destroy_cgroup(u);
1530
1531         /* Note that this doesn't apply to RemainAfterExit services exiting
1532          * sucessfully, since there's no change of state in that case. Which is
1533          * why it is handled in service_set_state() */
1534         if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1535                 ExecContext *ec;
1536
1537                 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_INACTIVE_OR_DEACTIVATING(ns))
1634                         check_unneeded_dependencies(u);
1635
1636                 if (ns != os && ns == UNIT_FAILED) {
1637                         log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1638                         unit_start_on_failure(u);
1639                 }
1640         }
1641
1642         /* Some names are special */
1643         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1644
1645                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1646                         /* The bus just might have become available,
1647                          * hence try to connect to it, if we aren't
1648                          * yet connected. */
1649                         bus_init(m, true);
1650
1651                 if (u->type == UNIT_SERVICE &&
1652                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1653                     m->n_reloading <= 0) {
1654                         /* Write audit record if we have just finished starting up */
1655                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1656                         u->in_audit = true;
1657                 }
1658
1659                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1660                         manager_send_unit_plymouth(m, u);
1661
1662         } else {
1663
1664                 /* We don't care about D-Bus here, since we'll get an
1665                  * asynchronous notification for it anyway. */
1666
1667                 if (u->type == UNIT_SERVICE &&
1668                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1669                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1670                     m->n_reloading <= 0) {
1671
1672                         /* Hmm, if there was no start record written
1673                          * write it now, so that we always have a nice
1674                          * pair */
1675                         if (!u->in_audit) {
1676                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1677
1678                                 if (ns == UNIT_INACTIVE)
1679                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1680                         } else
1681                                 /* Write audit record if we have just finished shutting down */
1682                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1683
1684                         u->in_audit = false;
1685                 }
1686         }
1687
1688         manager_recheck_journal(m);
1689         unit_trigger_notify(u);
1690
1691         /* Maybe we finished startup and are now ready for being
1692          * stopped because unneeded? */
1693         if (u->manager->n_reloading <= 0)
1694                 unit_check_unneeded(u);
1695
1696         unit_add_to_dbus_queue(u);
1697         unit_add_to_gc_queue(u);
1698 }
1699
1700 int unit_watch_pid(Unit *u, pid_t pid) {
1701         int q, r;
1702
1703         assert(u);
1704         assert(pid >= 1);
1705
1706         /* Watch a specific PID. We only support one or two units
1707          * watching each PID for now, not more. */
1708
1709         r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1710         if (r < 0)
1711                 return r;
1712
1713         r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1714         if (r < 0)
1715                 return r;
1716
1717         r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1718         if (r == -EEXIST) {
1719                 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1720                 if (r < 0)
1721                         return r;
1722
1723                 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1724         }
1725
1726         q = set_put(u->pids, LONG_TO_PTR(pid));
1727         if (q < 0)
1728                 return q;
1729
1730         return r;
1731 }
1732
1733 void unit_unwatch_pid(Unit *u, pid_t pid) {
1734         assert(u);
1735         assert(pid >= 1);
1736
1737         hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1738         hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1739         set_remove(u->pids, LONG_TO_PTR(pid));
1740 }
1741
1742 static int watch_pids_in_path(Unit *u, const char *path) {
1743         _cleanup_closedir_ DIR *d = NULL;
1744         _cleanup_fclose_ FILE *f = NULL;
1745         int ret = 0, r;
1746
1747         assert(u);
1748         assert(path);
1749
1750         /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1751
1752         r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1753         if (r >= 0) {
1754                 pid_t pid;
1755
1756                 while ((r = cg_read_pid(f, &pid)) > 0) {
1757                         r = unit_watch_pid(u, pid);
1758                         if (r < 0 && ret >= 0)
1759                                 ret = r;
1760                 }
1761                 if (r < 0 && ret >= 0)
1762                         ret = r;
1763
1764         } else if (ret >= 0)
1765                 ret = r;
1766
1767         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1768         if (r >= 0) {
1769                 char *fn;
1770
1771                 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1772                         _cleanup_free_ char *p = NULL;
1773
1774                         p = strjoin(path, "/", fn, NULL);
1775                         free(fn);
1776
1777                         if (!p)
1778                                 return -ENOMEM;
1779
1780                         r = watch_pids_in_path(u, p);
1781                         if (r < 0 && ret >= 0)
1782                                 ret = r;
1783                 }
1784                 if (r < 0 && ret >= 0)
1785                         ret = r;
1786
1787         } else if (ret >= 0)
1788                 ret = r;
1789
1790         return ret;
1791 }
1792
1793
1794 int unit_watch_all_pids(Unit *u) {
1795         assert(u);
1796
1797         if (!u->cgroup_path)
1798                 return -ENOENT;
1799
1800         /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1801
1802         return watch_pids_in_path(u, u->cgroup_path);
1803 }
1804
1805 void unit_unwatch_all_pids(Unit *u) {
1806         Iterator i;
1807         void *e;
1808
1809         assert(u);
1810
1811         SET_FOREACH(e, u->pids, i) {
1812                 hashmap_remove_value(u->manager->watch_pids1, e, u);
1813                 hashmap_remove_value(u->manager->watch_pids2, e, u);
1814         }
1815
1816         set_free(u->pids);
1817         u->pids = NULL;
1818 }
1819
1820 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1821         Iterator i;
1822         void *e;
1823
1824         assert(u);
1825
1826         /* Cleans dead PIDs from our list */
1827
1828         SET_FOREACH(e, u->pids, i) {
1829                 pid_t pid = PTR_TO_LONG(e);
1830
1831                 if (pid == except1 || pid == except2)
1832                         continue;
1833
1834                 if (!pid_is_unwaited(pid))
1835                         set_remove(u->pids, e);
1836         }
1837 }
1838
1839 bool unit_job_is_applicable(Unit *u, JobType j) {
1840         assert(u);
1841         assert(j >= 0 && j < _JOB_TYPE_MAX);
1842
1843         switch (j) {
1844
1845         case JOB_VERIFY_ACTIVE:
1846         case JOB_START:
1847         case JOB_STOP:
1848         case JOB_NOP:
1849                 return true;
1850
1851         case JOB_RESTART:
1852         case JOB_TRY_RESTART:
1853                 return unit_can_start(u);
1854
1855         case JOB_RELOAD:
1856                 return unit_can_reload(u);
1857
1858         case JOB_RELOAD_OR_START:
1859                 return unit_can_reload(u) && unit_can_start(u);
1860
1861         default:
1862                 assert_not_reached("Invalid job type");
1863         }
1864 }
1865
1866 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1867
1868         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1869                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1870                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1871                 [UNIT_WANTS] = UNIT_WANTED_BY,
1872                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1873                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1874                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1875                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1876                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1877                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1878                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1879                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1880                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1881                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1882                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1883                 [UNIT_BEFORE] = UNIT_AFTER,
1884                 [UNIT_AFTER] = UNIT_BEFORE,
1885                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1886                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1887                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1888                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1889                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1890                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1891                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1892                 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1893         };
1894         int r, q = 0, v = 0, w = 0;
1895
1896         assert(u);
1897         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1898         assert(other);
1899
1900         u = unit_follow_merge(u);
1901         other = unit_follow_merge(other);
1902
1903         /* We won't allow dependencies on ourselves. We will not
1904          * consider them an error however. */
1905         if (u == other)
1906                 return 0;
1907
1908         r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1909         if (r < 0)
1910                 return r;
1911
1912         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1913                 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1914                 if (r < 0)
1915                         return r;
1916         }
1917
1918         if (add_reference) {
1919                 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1920                 if (r < 0)
1921                         return r;
1922
1923                 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1924                 if (r < 0)
1925                         return r;
1926         }
1927
1928         q = set_put(u->dependencies[d], other);
1929         if (q < 0)
1930                 return q;
1931
1932         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1933                 v = set_put(other->dependencies[inverse_table[d]], u);
1934                 if (v < 0) {
1935                         r = v;
1936                         goto fail;
1937                 }
1938         }
1939
1940         if (add_reference) {
1941                 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1942                 if (w < 0) {
1943                         r = w;
1944                         goto fail;
1945                 }
1946
1947                 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1948                 if (r < 0)
1949                         goto fail;
1950         }
1951
1952         unit_add_to_dbus_queue(u);
1953         return 0;
1954
1955 fail:
1956         if (q > 0)
1957                 set_remove(u->dependencies[d], other);
1958
1959         if (v > 0)
1960                 set_remove(other->dependencies[inverse_table[d]], u);
1961
1962         if (w > 0)
1963                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1964
1965         return r;
1966 }
1967
1968 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1969         int r;
1970
1971         assert(u);
1972
1973         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1974                 return r;
1975
1976         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1977                 return r;
1978
1979         return 0;
1980 }
1981
1982 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1983         char *s;
1984
1985         assert(u);
1986         assert(name || path);
1987         assert(p);
1988
1989         if (!name)
1990                 name = basename(path);
1991
1992         if (!unit_name_is_template(name)) {
1993                 *p = NULL;
1994                 return name;
1995         }
1996
1997         if (u->instance)
1998                 s = unit_name_replace_instance(name, u->instance);
1999         else {
2000                 _cleanup_free_ char *i = NULL;
2001
2002                 i = unit_name_to_prefix(u->id);
2003                 if (!i)
2004                         return NULL;
2005
2006                 s = unit_name_replace_instance(name, i);
2007         }
2008
2009         if (!s)
2010                 return NULL;
2011
2012         *p = s;
2013         return s;
2014 }
2015
2016 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2017         Unit *other;
2018         int r;
2019         _cleanup_free_ char *s = NULL;
2020
2021         assert(u);
2022         assert(name || path);
2023
2024         name = resolve_template(u, name, path, &s);
2025         if (!name)
2026                 return -ENOMEM;
2027
2028         r = manager_load_unit(u->manager, name, path, NULL, &other);
2029         if (r < 0)
2030                 return r;
2031
2032         return unit_add_dependency(u, d, other, add_reference);
2033 }
2034
2035 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2036         Unit *other;
2037         int r;
2038         _cleanup_free_ char *s = NULL;
2039
2040         assert(u);
2041         assert(name || path);
2042
2043         if (!(name = resolve_template(u, name, path, &s)))
2044                 return -ENOMEM;
2045
2046         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2047                 return r;
2048
2049         r = unit_add_two_dependencies(u, d, e, other, add_reference);
2050
2051         return r;
2052 }
2053
2054 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2055         Unit *other;
2056         int r;
2057         _cleanup_free_ char *s = NULL;
2058
2059         assert(u);
2060         assert(name || path);
2061
2062         if (!(name = resolve_template(u, name, path, &s)))
2063                 return -ENOMEM;
2064
2065         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2066                 return r;
2067
2068         r = unit_add_dependency(other, d, u, add_reference);
2069
2070         return r;
2071 }
2072
2073 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2074         Unit *other;
2075         int r;
2076         _cleanup_free_ char *s = NULL;
2077
2078         assert(u);
2079         assert(name || path);
2080
2081         if (!(name = resolve_template(u, name, path, &s)))
2082                 return -ENOMEM;
2083
2084         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2085                 return r;
2086
2087         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2088                 return r;
2089
2090         return r;
2091 }
2092
2093 int set_unit_path(const char *p) {
2094         _cleanup_free_ char *c = NULL;
2095
2096         /* This is mostly for debug purposes */
2097         c = path_make_absolute_cwd(p);
2098         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2099                 return -errno;
2100
2101         return 0;
2102 }
2103
2104 char *unit_dbus_path(Unit *u) {
2105         assert(u);
2106
2107         if (!u->id)
2108                 return NULL;
2109
2110         return unit_dbus_path_from_name(u->id);
2111 }
2112
2113 char *unit_default_cgroup_path(Unit *u) {
2114         _cleanup_free_ char *escaped = NULL, *slice = NULL;
2115         int r;
2116
2117         assert(u);
2118
2119         if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2120                 return strdup(u->manager->cgroup_root);
2121
2122         if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2123                 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2124                 if (r < 0)
2125                         return NULL;
2126         }
2127
2128         escaped = cg_escape(u->id);
2129         if (!escaped)
2130                 return NULL;
2131
2132         if (slice)
2133                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2134         else
2135                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2136 }
2137
2138 int unit_add_default_slice(Unit *u) {
2139         _cleanup_free_ char *b = NULL;
2140         const char *slice_name;
2141         Unit *slice;
2142         int r;
2143
2144         assert(u);
2145
2146         if (UNIT_ISSET(u->slice))
2147                 return 0;
2148
2149         if (!unit_get_cgroup_context(u))
2150                 return 0;
2151
2152         if (u->instance) {
2153                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2154
2155                 /* Implicitly place all instantiated units in their
2156                  * own per-template slice */
2157
2158                 prefix = unit_name_to_prefix(u->id);
2159                 if (!prefix)
2160                         return -ENOMEM;
2161
2162                 /* The prefix is already escaped, but it might include
2163                  * "-" which has a special meaning for slice units,
2164                  * hence escape it here extra. */
2165                 escaped = strreplace(prefix, "-", "\\x2d");
2166                 if (!escaped)
2167                         return -ENOMEM;
2168
2169                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2170                         b = strjoin("system-", escaped, ".slice", NULL);
2171                 else
2172                         b = strappend(escaped, ".slice");
2173                 if (!b)
2174                         return -ENOMEM;
2175
2176                 slice_name = b;
2177         } else
2178                 slice_name =
2179                         u->manager->running_as == SYSTEMD_SYSTEM
2180                         ? SPECIAL_SYSTEM_SLICE
2181                         : SPECIAL_ROOT_SLICE;
2182
2183         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2184         if (r < 0)
2185                 return r;
2186
2187         unit_ref_set(&u->slice, slice);
2188         return 0;
2189 }
2190
2191 const char *unit_slice_name(Unit *u) {
2192         assert(u);
2193
2194         if (!UNIT_ISSET(u->slice))
2195                 return NULL;
2196
2197         return UNIT_DEREF(u->slice)->id;
2198 }
2199
2200 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2201         _cleanup_free_ char *t = NULL;
2202         int r;
2203
2204         assert(u);
2205         assert(type);
2206         assert(_found);
2207
2208         t = unit_name_change_suffix(u->id, type);
2209         if (!t)
2210                 return -ENOMEM;
2211
2212         assert(!unit_has_name(u, t));
2213
2214         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2215         assert(r < 0 || *_found != u);
2216         return r;
2217 }
2218
2219 int unit_watch_bus_name(Unit *u, const char *name) {
2220         assert(u);
2221         assert(name);
2222
2223         /* Watch a specific name on the bus. We only support one unit
2224          * watching each name for now. */
2225
2226         return hashmap_put(u->manager->watch_bus, name, u);
2227 }
2228
2229 void unit_unwatch_bus_name(Unit *u, const char *name) {
2230         assert(u);
2231         assert(name);
2232
2233         hashmap_remove_value(u->manager->watch_bus, name, u);
2234 }
2235
2236 bool unit_can_serialize(Unit *u) {
2237         assert(u);
2238
2239         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2240 }
2241
2242 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2243         ExecRuntime *rt;
2244         int r;
2245
2246         assert(u);
2247         assert(f);
2248         assert(fds);
2249
2250         if (!unit_can_serialize(u))
2251                 return 0;
2252
2253         r = UNIT_VTABLE(u)->serialize(u, f, fds);
2254         if (r < 0)
2255                 return r;
2256
2257         rt = unit_get_exec_runtime(u);
2258         if (rt) {
2259                 r = exec_runtime_serialize(rt, u, f, fds);
2260                 if (r < 0)
2261                         return r;
2262         }
2263
2264         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2265         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2266         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2267         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2268         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2269
2270         if (dual_timestamp_is_set(&u->condition_timestamp))
2271                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2272
2273         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2274
2275         if (u->cgroup_path)
2276                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2277
2278         if (serialize_jobs) {
2279                 if (u->job) {
2280                         fprintf(f, "job\n");
2281                         job_serialize(u->job, f, fds);
2282                 }
2283
2284                 if (u->nop_job) {
2285                         fprintf(f, "job\n");
2286                         job_serialize(u->nop_job, f, fds);
2287                 }
2288         }
2289
2290         /* End marker */
2291         fputc('\n', f);
2292         return 0;
2293 }
2294
2295 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2296         va_list ap;
2297
2298         assert(u);
2299         assert(f);
2300         assert(key);
2301         assert(format);
2302
2303         fputs(key, f);
2304         fputc('=', f);
2305
2306         va_start(ap, format);
2307         vfprintf(f, format, ap);
2308         va_end(ap);
2309
2310         fputc('\n', f);
2311 }
2312
2313 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2314         assert(u);
2315         assert(f);
2316         assert(key);
2317         assert(value);
2318
2319         fprintf(f, "%s=%s\n", key, value);
2320 }
2321
2322 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2323         size_t offset;
2324         ExecRuntime **rt = NULL;
2325         int r;
2326
2327         assert(u);
2328         assert(f);
2329         assert(fds);
2330
2331         if (!unit_can_serialize(u))
2332                 return 0;
2333
2334         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2335         if (offset > 0)
2336                 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2337
2338         for (;;) {
2339                 char line[LINE_MAX], *l, *v;
2340                 size_t k;
2341
2342                 if (!fgets(line, sizeof(line), f)) {
2343                         if (feof(f))
2344                                 return 0;
2345                         return -errno;
2346                 }
2347
2348                 char_array_0(line);
2349                 l = strstrip(line);
2350
2351                 /* End marker */
2352                 if (l[0] == 0)
2353                         return 0;
2354
2355                 k = strcspn(l, "=");
2356
2357                 if (l[k] == '=') {
2358                         l[k] = 0;
2359                         v = l+k+1;
2360                 } else
2361                         v = l+k;
2362
2363                 if (streq(l, "job")) {
2364                         if (v[0] == '\0') {
2365                                 /* new-style serialized job */
2366                                 Job *j = job_new_raw(u);
2367                                 if (!j)
2368                                         return -ENOMEM;
2369
2370                                 r = job_deserialize(j, f, fds);
2371                                 if (r < 0) {
2372                                         job_free(j);
2373                                         return r;
2374                                 }
2375
2376                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2377                                 if (r < 0) {
2378                                         job_free(j);
2379                                         return r;
2380                                 }
2381
2382                                 r = job_install_deserialized(j);
2383                                 if (r < 0) {
2384                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2385                                         job_free(j);
2386                                         return r;
2387                                 }
2388
2389                                 if (j->state == JOB_RUNNING)
2390                                         u->manager->n_running_jobs++;
2391                         } else {
2392                                 /* legacy */
2393                                 JobType type = job_type_from_string(v);
2394                                 if (type < 0)
2395                                         log_debug("Failed to parse job type value %s", v);
2396                                 else
2397                                         u->deserialized_job = type;
2398                         }
2399                         continue;
2400                 } else if (streq(l, "inactive-exit-timestamp")) {
2401                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2402                         continue;
2403                 } else if (streq(l, "active-enter-timestamp")) {
2404                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2405                         continue;
2406                 } else if (streq(l, "active-exit-timestamp")) {
2407                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2408                         continue;
2409                 } else if (streq(l, "inactive-enter-timestamp")) {
2410                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2411                         continue;
2412                 } else if (streq(l, "condition-timestamp")) {
2413                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2414                         continue;
2415                 } else if (streq(l, "condition-result")) {
2416                         int b;
2417
2418                         b = parse_boolean(v);
2419                         if (b < 0)
2420                                 log_debug("Failed to parse condition result value %s", v);
2421                         else
2422                                 u->condition_result = b;
2423
2424                         continue;
2425
2426                 } else if (streq(l, "transient")) {
2427                         int b;
2428
2429                         b = parse_boolean(v);
2430                         if (b < 0)
2431                                 log_debug("Failed to parse transient bool %s", v);
2432                         else
2433                                 u->transient = b;
2434
2435                         continue;
2436                 } else if (streq(l, "cgroup")) {
2437                         char *s;
2438
2439                         s = strdup(v);
2440                         if (!s)
2441                                 return -ENOMEM;
2442
2443                         free(u->cgroup_path);
2444                         u->cgroup_path = s;
2445
2446                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2447                         continue;
2448                 }
2449
2450                 if (rt) {
2451                         r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2452                         if (r < 0)
2453                                 return r;
2454                         if (r > 0)
2455                                 continue;
2456                 }
2457
2458                 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2459                 if (r < 0)
2460                         return r;
2461         }
2462 }
2463
2464 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2465         Unit *device;
2466         _cleanup_free_ char *e = NULL;
2467         int r;
2468
2469         assert(u);
2470
2471         if (!what)
2472                 return 0;
2473
2474         /* Adds in links to the device node that this unit is based on */
2475
2476         if (!is_device_path(what))
2477                 return 0;
2478
2479         e = unit_name_from_path(what, ".device");
2480         if (!e)
2481                 return -ENOMEM;
2482
2483         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2484
2485         if (r < 0)
2486                 return r;
2487
2488         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2489         if (r < 0)
2490                 return r;
2491
2492         if (wants) {
2493                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2494                 if (r < 0)
2495                         return r;
2496         }
2497
2498         return 0;
2499 }
2500
2501 int unit_coldplug(Unit *u) {
2502         int r;
2503
2504         assert(u);
2505
2506         if (UNIT_VTABLE(u)->coldplug)
2507                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2508                         return r;
2509
2510         if (u->job) {
2511                 r = job_coldplug(u->job);
2512                 if (r < 0)
2513                         return r;
2514         } else if (u->deserialized_job >= 0) {
2515                 /* legacy */
2516                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2517                 if (r < 0)
2518                         return r;
2519
2520                 u->deserialized_job = _JOB_TYPE_INVALID;
2521         }
2522
2523         return 0;
2524 }
2525
2526 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2527         DISABLE_WARNING_FORMAT_NONLITERAL;
2528         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2529         REENABLE_WARNING;
2530 }
2531
2532 bool unit_need_daemon_reload(Unit *u) {
2533         _cleanup_strv_free_ char **t = NULL;
2534         char **path;
2535         struct stat st;
2536         unsigned loaded_cnt, current_cnt;
2537
2538         assert(u);
2539
2540         if (u->fragment_path) {
2541                 zero(st);
2542                 if (stat(u->fragment_path, &st) < 0)
2543                         /* What, cannot access this anymore? */
2544                         return true;
2545
2546                 if (u->fragment_mtime > 0 &&
2547                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2548                         return true;
2549         }
2550
2551         if (u->source_path) {
2552                 zero(st);
2553                 if (stat(u->source_path, &st) < 0)
2554                         return true;
2555
2556                 if (u->source_mtime > 0 &&
2557                     timespec_load(&st.st_mtim) != u->source_mtime)
2558                         return true;
2559         }
2560
2561         t = unit_find_dropin_paths(u);
2562         loaded_cnt = strv_length(t);
2563         current_cnt = strv_length(u->dropin_paths);
2564
2565         if (loaded_cnt == current_cnt) {
2566                 if (loaded_cnt == 0)
2567                         return false;
2568
2569                 if (strv_overlap(u->dropin_paths, t)) {
2570                         STRV_FOREACH(path, u->dropin_paths) {
2571                                 zero(st);
2572                                 if (stat(*path, &st) < 0)
2573                                         return true;
2574
2575                                 if (u->dropin_mtime > 0 &&
2576                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2577                                         return true;
2578                         }
2579
2580                         return false;
2581                 } else
2582                         return true;
2583         } else
2584                 return true;
2585 }
2586
2587 void unit_reset_failed(Unit *u) {
2588         assert(u);
2589
2590         if (UNIT_VTABLE(u)->reset_failed)
2591                 UNIT_VTABLE(u)->reset_failed(u);
2592 }
2593
2594 Unit *unit_following(Unit *u) {
2595         assert(u);
2596
2597         if (UNIT_VTABLE(u)->following)
2598                 return UNIT_VTABLE(u)->following(u);
2599
2600         return NULL;
2601 }
2602
2603 bool unit_stop_pending(Unit *u) {
2604         assert(u);
2605
2606         /* This call does check the current state of the unit. It's
2607          * hence useful to be called from state change calls of the
2608          * unit itself, where the state isn't updated yet. This is
2609          * different from unit_inactive_or_pending() which checks both
2610          * the current state and for a queued job. */
2611
2612         return u->job && u->job->type == JOB_STOP;
2613 }
2614
2615 bool unit_inactive_or_pending(Unit *u) {
2616         assert(u);
2617
2618         /* Returns true if the unit is inactive or going down */
2619
2620         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2621                 return true;
2622
2623         if (unit_stop_pending(u))
2624                 return true;
2625
2626         return false;
2627 }
2628
2629 bool unit_active_or_pending(Unit *u) {
2630         assert(u);
2631
2632         /* Returns true if the unit is active or going up */
2633
2634         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2635                 return true;
2636
2637         if (u->job &&
2638             (u->job->type == JOB_START ||
2639              u->job->type == JOB_RELOAD_OR_START ||
2640              u->job->type == JOB_RESTART))
2641                 return true;
2642
2643         return false;
2644 }
2645
2646 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2647         assert(u);
2648         assert(w >= 0 && w < _KILL_WHO_MAX);
2649         assert(signo > 0);
2650         assert(signo < _NSIG);
2651
2652         if (!UNIT_VTABLE(u)->kill)
2653                 return -ENOTSUP;
2654
2655         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2656 }
2657
2658 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2659         Set *pid_set;
2660         int r;
2661
2662         pid_set = set_new(trivial_hash_func, trivial_compare_func);
2663         if (!pid_set)
2664                 return NULL;
2665
2666         /* Exclude the main/control pids from being killed via the cgroup */
2667         if (main_pid > 0) {
2668                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2669                 if (r < 0)
2670                         goto fail;
2671         }
2672
2673         if (control_pid > 0) {
2674                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2675                 if (r < 0)
2676                         goto fail;
2677         }
2678
2679         return pid_set;
2680
2681 fail:
2682         set_free(pid_set);
2683         return NULL;
2684 }
2685
2686 int unit_kill_common(
2687                 Unit *u,
2688                 KillWho who,
2689                 int signo,
2690                 pid_t main_pid,
2691                 pid_t control_pid,
2692                 sd_bus_error *error) {
2693
2694         int r = 0;
2695
2696         if (who == KILL_MAIN && main_pid <= 0) {
2697                 if (main_pid < 0)
2698                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2699                 else
2700                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2701                 return -ESRCH;
2702         }
2703
2704         if (who == KILL_CONTROL && control_pid <= 0) {
2705                 if (control_pid < 0)
2706                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2707                 else
2708                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2709                 return -ESRCH;
2710         }
2711
2712         if (who == KILL_CONTROL || who == KILL_ALL)
2713                 if (control_pid > 0)
2714                         if (kill(control_pid, signo) < 0)
2715                                 r = -errno;
2716
2717         if (who == KILL_MAIN || who == KILL_ALL)
2718                 if (main_pid > 0)
2719                         if (kill(main_pid, signo) < 0)
2720                                 r = -errno;
2721
2722         if (who == KILL_ALL && u->cgroup_path) {
2723                 _cleanup_set_free_ Set *pid_set = NULL;
2724                 int q;
2725
2726                 /* Exclude the main/control pids from being killed via the cgroup */
2727                 pid_set = unit_pid_set(main_pid, control_pid);
2728                 if (!pid_set)
2729                         return -ENOMEM;
2730
2731                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2732                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2733                         r = q;
2734         }
2735
2736         return r;
2737 }
2738
2739 int unit_following_set(Unit *u, Set **s) {
2740         assert(u);
2741         assert(s);
2742
2743         if (UNIT_VTABLE(u)->following_set)
2744                 return UNIT_VTABLE(u)->following_set(u, s);
2745
2746         *s = NULL;
2747         return 0;
2748 }
2749
2750 UnitFileState unit_get_unit_file_state(Unit *u) {
2751         assert(u);
2752
2753         if (u->unit_file_state < 0 && u->fragment_path)
2754                 u->unit_file_state = unit_file_get_state(
2755                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2756                                 NULL, basename(u->fragment_path));
2757
2758         return u->unit_file_state;
2759 }
2760
2761 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2762         assert(ref);
2763         assert(u);
2764
2765         if (ref->unit)
2766                 unit_ref_unset(ref);
2767
2768         ref->unit = u;
2769         LIST_PREPEND(refs, u->refs, ref);
2770         return u;
2771 }
2772
2773 void unit_ref_unset(UnitRef *ref) {
2774         assert(ref);
2775
2776         if (!ref->unit)
2777                 return;
2778
2779         LIST_REMOVE(refs, ref->unit->refs, ref);
2780         ref->unit = NULL;
2781 }
2782
2783 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2784         unsigned i;
2785         int r;
2786
2787         assert(u);
2788         assert(c);
2789
2790         /* This only copies in the ones that need memory */
2791         for (i = 0; i < RLIMIT_NLIMITS; i++)
2792                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2793                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2794                         if (!c->rlimit[i])
2795                                 return -ENOMEM;
2796                 }
2797
2798         if (u->manager->running_as == SYSTEMD_USER &&
2799             !c->working_directory) {
2800
2801                 r = get_home_dir(&c->working_directory);
2802                 if (r < 0)
2803                         return r;
2804         }
2805
2806         return 0;
2807 }
2808
2809 ExecContext *unit_get_exec_context(Unit *u) {
2810         size_t offset;
2811         assert(u);
2812
2813         offset = UNIT_VTABLE(u)->exec_context_offset;
2814         if (offset <= 0)
2815                 return NULL;
2816
2817         return (ExecContext*) ((uint8_t*) u + offset);
2818 }
2819
2820 KillContext *unit_get_kill_context(Unit *u) {
2821         size_t offset;
2822         assert(u);
2823
2824         offset = UNIT_VTABLE(u)->kill_context_offset;
2825         if (offset <= 0)
2826                 return NULL;
2827
2828         return (KillContext*) ((uint8_t*) u + offset);
2829 }
2830
2831 CGroupContext *unit_get_cgroup_context(Unit *u) {
2832         size_t offset;
2833
2834         offset = UNIT_VTABLE(u)->cgroup_context_offset;
2835         if (offset <= 0)
2836                 return NULL;
2837
2838         return (CGroupContext*) ((uint8_t*) u + offset);
2839 }
2840
2841 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2842         size_t offset;
2843
2844         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2845         if (offset <= 0)
2846                 return NULL;
2847
2848         return *(ExecRuntime**) ((uint8_t*) u + offset);
2849 }
2850
2851 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2852         _cleanup_free_ char *b = NULL;
2853         char *p, *q;
2854         int r;
2855
2856         assert(u);
2857         assert(name);
2858         assert(_p);
2859         assert(_q);
2860
2861         b = xescape(name, "/.");
2862         if (!b)
2863                 return -ENOMEM;
2864
2865         if (!filename_is_safe(b))
2866                 return -EINVAL;
2867
2868         if (u->manager->running_as == SYSTEMD_USER) {
2869                 _cleanup_free_ char *c = NULL;
2870
2871                 r = user_config_home(&c);
2872                 if (r < 0)
2873                         return r;
2874                 if (r == 0)
2875                         return -ENOENT;
2876
2877                 p = strjoin(c, "/", u->id, ".d", NULL);
2878         } else if (mode == UNIT_PERSISTENT && !u->transient)
2879                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2880         else
2881                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2882         if (!p)
2883                 return -ENOMEM;
2884
2885         q = strjoin(p, "/90-", b, ".conf", NULL);
2886         if (!q) {
2887                 free(p);
2888                 return -ENOMEM;
2889         }
2890
2891         *_p = p;
2892         *_q = q;
2893         return 0;
2894 }
2895
2896 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2897         _cleanup_free_ char *p = NULL, *q = NULL;
2898         int r;
2899
2900         assert(u);
2901         assert(name);
2902         assert(data);
2903
2904         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2905                 return 0;
2906
2907         r = drop_in_file(u, mode, name, &p, &q);
2908         if (r < 0)
2909                 return r;
2910
2911         mkdir_p(p, 0755);
2912         return write_string_file_atomic_label(q, data);
2913 }
2914
2915 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2916         _cleanup_free_ char *p = NULL;
2917         va_list ap;
2918         int r;
2919
2920         assert(u);
2921         assert(name);
2922         assert(format);
2923
2924         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2925                 return 0;
2926
2927         va_start(ap, format);
2928         r = vasprintf(&p, format, ap);
2929         va_end(ap);
2930
2931         if (r < 0)
2932                 return -ENOMEM;
2933
2934         return unit_write_drop_in(u, mode, name, p);
2935 }
2936
2937 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2938         _cleanup_free_ char *ndata = NULL;
2939
2940         assert(u);
2941         assert(name);
2942         assert(data);
2943
2944         if (!UNIT_VTABLE(u)->private_section)
2945                 return -EINVAL;
2946
2947         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2948                 return 0;
2949
2950         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2951         if (!ndata)
2952                 return -ENOMEM;
2953
2954         return unit_write_drop_in(u, mode, name, ndata);
2955 }
2956
2957 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2958         _cleanup_free_ char *p = NULL;
2959         va_list ap;
2960         int r;
2961
2962         assert(u);
2963         assert(name);
2964         assert(format);
2965
2966         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2967                 return 0;
2968
2969         va_start(ap, format);
2970         r = vasprintf(&p, format, ap);
2971         va_end(ap);
2972
2973         if (r < 0)
2974                 return -ENOMEM;
2975
2976         return unit_write_drop_in_private(u, mode, name, p);
2977 }
2978
2979 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2980         _cleanup_free_ char *p = NULL, *q = NULL;
2981         int r;
2982
2983         assert(u);
2984
2985         if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
2986                 return 0;
2987
2988         r = drop_in_file(u, mode, name, &p, &q);
2989         if (r < 0)
2990                 return r;
2991
2992         if (unlink(q) < 0)
2993                 r = errno == ENOENT ? 0 : -errno;
2994         else
2995                 r = 1;
2996
2997         rmdir(p);
2998         return r;
2999 }
3000
3001 int unit_make_transient(Unit *u) {
3002         int r;
3003
3004         assert(u);
3005
3006         u->load_state = UNIT_STUB;
3007         u->load_error = 0;
3008         u->transient = true;
3009
3010         free(u->fragment_path);
3011         u->fragment_path = NULL;
3012
3013         if (u->manager->running_as == SYSTEMD_USER) {
3014                 _cleanup_free_ char *c = NULL;
3015
3016                 r = user_config_home(&c);
3017                 if (r < 0)
3018                         return r;
3019                 if (r == 0)
3020                         return -ENOENT;
3021
3022                 u->fragment_path = strjoin(c, "/", u->id, NULL);
3023                 if (!u->fragment_path)
3024                         return -ENOMEM;
3025
3026                 mkdir_p(c, 0755);
3027         } else {
3028                 u->fragment_path = strappend("/run/systemd/system/", u->id);
3029                 if (!u->fragment_path)
3030                         return -ENOMEM;
3031
3032                 mkdir_p("/run/systemd/system", 0755);
3033         }
3034
3035         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3036 }
3037
3038 int unit_kill_context(
3039                 Unit *u,
3040                 KillContext *c,
3041                 bool sigkill,
3042                 pid_t main_pid,
3043                 pid_t control_pid,
3044                 bool main_pid_alien) {
3045
3046         int sig, wait_for_exit = false, r;
3047
3048         assert(u);
3049         assert(c);
3050
3051         if (c->kill_mode == KILL_NONE)
3052                 return 0;
3053
3054         sig = sigkill ? SIGKILL : c->kill_signal;
3055
3056         if (main_pid > 0) {
3057                 r = kill_and_sigcont(main_pid, sig);
3058
3059                 if (r < 0 && r != -ESRCH) {
3060                         _cleanup_free_ char *comm = NULL;
3061                         get_process_comm(main_pid, &comm);
3062
3063                         log_warning_unit(u->id, "Failed to kill main process " PID_FMT " (%s): %s", main_pid, strna(comm), strerror(-r));
3064                 } else {
3065                         if (!main_pid_alien)
3066                                 wait_for_exit = true;
3067
3068                         if (c->send_sighup && !sigkill)
3069                                 kill(main_pid, SIGHUP);
3070                 }
3071         }
3072
3073         if (control_pid > 0) {
3074                 r = kill_and_sigcont(control_pid, sig);
3075
3076                 if (r < 0 && r != -ESRCH) {
3077                         _cleanup_free_ char *comm = NULL;
3078                         get_process_comm(control_pid, &comm);
3079
3080                         log_warning_unit(u->id, "Failed to kill control process " PID_FMT " (%s): %s", control_pid, strna(comm), strerror(-r));
3081                 } else {
3082                         wait_for_exit = true;
3083
3084                         if (c->send_sighup && !sigkill)
3085                                 kill(control_pid, SIGHUP);
3086                 }
3087         }
3088
3089         if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && sigkill)) && u->cgroup_path) {
3090                 _cleanup_set_free_ Set *pid_set = NULL;
3091
3092                 /* Exclude the main/control pids from being killed via the cgroup */
3093                 pid_set = unit_pid_set(main_pid, control_pid);
3094                 if (!pid_set)
3095                         return -ENOMEM;
3096
3097                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3098                 if (r < 0) {
3099                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3100                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3101                 } else if (r > 0) {
3102
3103                         /* FIXME: For now, we will not wait for the
3104                          * cgroup members to die, simply because
3105                          * cgroup notification is unreliable. It
3106                          * doesn't work at all in containers, and
3107                          * outside of containers it can be confused
3108                          * easily by leaving directories in the
3109                          * cgroup. */
3110
3111                         /* wait_for_exit = true; */
3112
3113                         if (c->send_sighup && !sigkill) {
3114                                 set_free(pid_set);
3115
3116                                 pid_set = unit_pid_set(main_pid, control_pid);
3117                                 if (!pid_set)
3118                                         return -ENOMEM;
3119
3120                                 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3121                         }
3122                 }
3123         }
3124
3125         return wait_for_exit;
3126 }
3127
3128 int unit_require_mounts_for(Unit *u, const char *path) {
3129         char prefix[strlen(path) + 1], *p;
3130         int r;
3131
3132         assert(u);
3133         assert(path);
3134
3135         /* Registers a unit for requiring a certain path and all its
3136          * prefixes. We keep a simple array of these paths in the
3137          * unit, since its usually short. However, we build a prefix
3138          * table for all possible prefixes so that new appearing mount
3139          * units can easily determine which units to make themselves a
3140          * dependency of. */
3141
3142         if (!path_is_absolute(path))
3143                 return -EINVAL;
3144
3145         p = strdup(path);
3146         if (!p)
3147                 return -ENOMEM;
3148
3149         path_kill_slashes(p);
3150
3151         if (!path_is_safe(p)) {
3152                 free(p);
3153                 return -EPERM;
3154         }
3155
3156         if (strv_contains(u->requires_mounts_for, p)) {
3157                 free(p);
3158                 return 0;
3159         }
3160
3161         r = strv_push(&u->requires_mounts_for, p);
3162         if (r < 0) {
3163                 free(p);
3164                 return r;
3165         }
3166
3167         PATH_FOREACH_PREFIX_MORE(prefix, p) {
3168                 Set *x;
3169
3170                 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3171                 if (!x) {
3172                         char *q;
3173
3174                         if (!u->manager->units_requiring_mounts_for) {
3175                                 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3176                                 if (!u->manager->units_requiring_mounts_for)
3177                                         return -ENOMEM;
3178                         }
3179
3180                         q = strdup(prefix);
3181                         if (!q)
3182                                 return -ENOMEM;
3183
3184                         x = set_new(NULL, NULL);
3185                         if (!x) {
3186                                 free(q);
3187                                 return -ENOMEM;
3188                         }
3189
3190                         r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3191                         if (r < 0) {
3192                                 free(q);
3193                                 set_free(x);
3194                                 return r;
3195                         }
3196                 }
3197
3198                 r = set_put(x, u);
3199                 if (r < 0)
3200                         return r;
3201         }
3202
3203         return 0;
3204 }
3205
3206 int unit_setup_exec_runtime(Unit *u) {
3207         ExecRuntime **rt;
3208         size_t offset;
3209         Iterator i;
3210         Unit *other;
3211
3212         offset = UNIT_VTABLE(u)->exec_runtime_offset;
3213         assert(offset > 0);
3214
3215         /* Check if ther already is an ExecRuntime for this unit? */
3216         rt = (ExecRuntime**) ((uint8_t*) u + offset);
3217         if (*rt)
3218                 return 0;
3219
3220         /* Try to get it from somebody else */
3221         SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3222
3223                 *rt = unit_get_exec_runtime(other);
3224                 if (*rt) {
3225                         exec_runtime_ref(*rt);
3226                         return 0;
3227                 }
3228         }
3229
3230         return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3231 }
3232
3233 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3234         [UNIT_ACTIVE] = "active",
3235         [UNIT_RELOADING] = "reloading",
3236         [UNIT_INACTIVE] = "inactive",
3237         [UNIT_FAILED] = "failed",
3238         [UNIT_ACTIVATING] = "activating",
3239         [UNIT_DEACTIVATING] = "deactivating"
3240 };
3241
3242 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3243
3244 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3245         [UNIT_REQUIRES] = "Requires",
3246         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3247         [UNIT_REQUISITE] = "Requisite",
3248         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3249         [UNIT_WANTS] = "Wants",
3250         [UNIT_BINDS_TO] = "BindsTo",
3251         [UNIT_PART_OF] = "PartOf",
3252         [UNIT_REQUIRED_BY] = "RequiredBy",
3253         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3254         [UNIT_WANTED_BY] = "WantedBy",
3255         [UNIT_BOUND_BY] = "BoundBy",
3256         [UNIT_CONSISTS_OF] = "ConsistsOf",
3257         [UNIT_CONFLICTS] = "Conflicts",
3258         [UNIT_CONFLICTED_BY] = "ConflictedBy",
3259         [UNIT_BEFORE] = "Before",
3260         [UNIT_AFTER] = "After",
3261         [UNIT_ON_FAILURE] = "OnFailure",
3262         [UNIT_TRIGGERS] = "Triggers",
3263         [UNIT_TRIGGERED_BY] = "TriggeredBy",
3264         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3265         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3266         [UNIT_REFERENCES] = "References",
3267         [UNIT_REFERENCED_BY] = "ReferencedBy",
3268         [UNIT_JOINS_NAMESPACE_OF] = "JoinsNamespaceOf",
3269 };
3270
3271 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);