src/core/unit.c

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