src/core/unit.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <sys/epoll.h>
  26 #include <sys/timerfd.h>
  27 #include <sys/poll.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <sys/stat.h>
  31
  32 #include "sd-id128.h"
  33 #include "sd-messages.h"
  34 #include "set.h"
  35 #include "unit.h"
  36 #include "macro.h"
  37 #include "strv.h"
  38 #include "path-util.h"
  39 #include "load-fragment.h"
  40 #include "load-dropin.h"
  41 #include "log.h"
  42 #include "unit-name.h"
  43 #include "dbus-unit.h"
  44 #include "special.h"
  45 #include "cgroup-util.h"
  46 #include "missing.h"
  47 #include "mkdir.h"
  48 #include "label.h"
  49 #include "fileio-label.h"
  50 #include "bus-errors.h"
  51 #include "dbus.h"
  52 #include "execute.h"
  53 #include "virt.h"
  54
  55 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
  56         [UNIT_SERVICE] = &service_vtable,
  57         [UNIT_SOCKET] = &socket_vtable,
  58         [UNIT_BUSNAME] = &busname_vtable,
  59         [UNIT_TARGET] = &target_vtable,
  60         [UNIT_SNAPSHOT] = &snapshot_vtable,
  61         [UNIT_DEVICE] = &device_vtable,
  62         [UNIT_MOUNT] = &mount_vtable,
  63         [UNIT_AUTOMOUNT] = &automount_vtable,
  64         [UNIT_SWAP] = &swap_vtable,
  65         [UNIT_TIMER] = &timer_vtable,
  66         [UNIT_PATH] = &path_vtable,
  67         [UNIT_SLICE] = &slice_vtable,
  68         [UNIT_SCOPE] = &scope_vtable
  69 };
  70
  71 Unit *unit_new(Manager *m, size_t size) {
  72         Unit *u;
  73
  74         assert(m);
  75         assert(size >= sizeof(Unit));
  76
  77         u = malloc0(size);
  78         if (!u)
  79                 return NULL;
  80
  81         u->names = set_new(string_hash_func, string_compare_func);
  82         if (!u->names) {
  83                 free(u);
  84                 return NULL;
  85         }
  86
  87         u->manager = m;
  88         u->type = _UNIT_TYPE_INVALID;
  89         u->deserialized_job = _JOB_TYPE_INVALID;
  90         u->default_dependencies = true;
  91         u->unit_file_state = _UNIT_FILE_STATE_INVALID;
  92         u->on_failure_job_mode = JOB_REPLACE;
  93
  94         return u;
  95 }
  96
  97 bool unit_has_name(Unit *u, const char *name) {
  98         assert(u);
  99         assert(name);
 100
 101         return !!set_get(u->names, (char*) name);
 102 }
 103
 104 int unit_add_name(Unit *u, const char *text) {
 105         UnitType t;
 106         char *s, *i = NULL;
 107         int r;
 108
 109         assert(u);
 110         assert(text);
 111
 112         if (unit_name_is_template(text)) {
 113                 if (!u->instance)
 114                         return -EINVAL;
 115
 116                 s = unit_name_replace_instance(text, u->instance);
 117         } else
 118                 s = strdup(text);
 119
 120         if (!s)
 121                 return -ENOMEM;
 122
 123         if (!unit_name_is_valid(s, TEMPLATE_INVALID)) {
 124                 r = -EINVAL;
 125                 goto fail;
 126         }
 127
 128         assert_se((t = unit_name_to_type(s)) >= 0);
 129
 130         if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
 131                 r = -EINVAL;
 132                 goto fail;
 133         }
 134
 135         r = unit_name_to_instance(s, &i);
 136         if (r < 0)
 137                 goto fail;
 138
 139         if (i && unit_vtable[t]->no_instances) {
 140                 r = -EINVAL;
 141                 goto fail;
 142         }
 143
 144         /* Ensure that this unit is either instanced or not instanced,
 145          * but not both. */
 146         if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
 147                 r = -EINVAL;
 148                 goto fail;
 149         }
 150
 151         if (unit_vtable[t]->no_alias &&
 152             !set_isempty(u->names) &&
 153             !set_get(u->names, s)) {
 154                 r = -EEXIST;
 155                 goto fail;
 156         }
 157
 158         if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
 159                 r = -E2BIG;
 160                 goto fail;
 161         }
 162
 163         r = set_put(u->names, s);
 164         if (r < 0) {
 165                 if (r == -EEXIST)
 166                         r = 0;
 167                 goto fail;
 168         }
 169
 170         r = hashmap_put(u->manager->units, s, u);
 171         if (r < 0) {
 172                 set_remove(u->names, s);
 173                 goto fail;
 174         }
 175
 176         if (u->type == _UNIT_TYPE_INVALID) {
 177
 178                 u->type = t;
 179                 u->id = s;
 180                 u->instance = i;
 181
 182                 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
 183
 184                 if (UNIT_VTABLE(u)->init)
 185                         UNIT_VTABLE(u)->init(u);
 186         } else
 187                 free(i);
 188
 189         unit_add_to_dbus_queue(u);
 190         return 0;
 191
 192 fail:
 193         free(s);
 194         free(i);
 195
 196         return r;
 197 }
 198
 199 int unit_choose_id(Unit *u, const char *name) {
 200         char *s, *i;
 201         _cleanup_free_ char *t = NULL;
 202         int r;
 203
 204         assert(u);
 205         assert(name);
 206
 207         if (unit_name_is_template(name)) {
 208
 209                 if (!u->instance)
 210                         return -EINVAL;
 211
 212                 t = unit_name_replace_instance(name, u->instance);
 213                 if (!t)
 214                         return -ENOMEM;
 215
 216                 name = t;
 217         }
 218
 219         /* Selects one of the names of this unit as the id */
 220         s = set_get(u->names, (char*) name);
 221
 222         if (!s)
 223                 return -ENOENT;
 224
 225         r = unit_name_to_instance(s, &i);
 226         if (r < 0)
 227                 return r;
 228
 229         u->id = s;
 230
 231         free(u->instance);
 232         u->instance = i;
 233
 234         unit_add_to_dbus_queue(u);
 235
 236         return 0;
 237 }
 238
 239 int unit_set_description(Unit *u, const char *description) {
 240         char *s;
 241
 242         assert(u);
 243
 244         if (isempty(description))
 245                 s = NULL;
 246         else {
 247                 s = strdup(description);
 248                 if (!s)
 249                         return -ENOMEM;
 250         }
 251
 252         free(u->description);
 253         u->description = s;
 254
 255         unit_add_to_dbus_queue(u);
 256         return 0;
 257 }
 258
 259 bool unit_check_gc(Unit *u) {
 260         assert(u);
 261
 262         if (u->load_state == UNIT_STUB)
 263                 return true;
 264
 265         if (UNIT_VTABLE(u)->no_gc)
 266                 return true;
 267
 268         if (u->no_gc)
 269                 return true;
 270
 271         if (u->job)
 272                 return true;
 273
 274         if (u->nop_job)
 275                 return true;
 276
 277         if (unit_active_state(u) != UNIT_INACTIVE)
 278                 return true;
 279
 280         if (u->refs)
 281                 return true;
 282
 283         if (UNIT_VTABLE(u)->check_gc)
 284                 if (UNIT_VTABLE(u)->check_gc(u))
 285                         return true;
 286
 287         return false;
 288 }
 289
 290 void unit_add_to_load_queue(Unit *u) {
 291         assert(u);
 292         assert(u->type != _UNIT_TYPE_INVALID);
 293
 294         if (u->load_state != UNIT_STUB || u->in_load_queue)
 295                 return;
 296
 297         LIST_PREPEND(load_queue, u->manager->load_queue, u);
 298         u->in_load_queue = true;
 299 }
 300
 301 void unit_add_to_cleanup_queue(Unit *u) {
 302         assert(u);
 303
 304         if (u->in_cleanup_queue)
 305                 return;
 306
 307         LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
 308         u->in_cleanup_queue = true;
 309 }
 310
 311 void unit_add_to_gc_queue(Unit *u) {
 312         assert(u);
 313
 314         if (u->in_gc_queue || u->in_cleanup_queue)
 315                 return;
 316
 317         if (unit_check_gc(u))
 318                 return;
 319
 320         LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
 321         u->in_gc_queue = true;
 322
 323         u->manager->n_in_gc_queue ++;
 324 }
 325
 326 void unit_add_to_dbus_queue(Unit *u) {
 327         assert(u);
 328         assert(u->type != _UNIT_TYPE_INVALID);
 329
 330         if (u->load_state == UNIT_STUB || u->in_dbus_queue)
 331                 return;
 332
 333         /* Shortcut things if nobody cares */
 334         if (set_isempty(u->manager->subscribed)) {
 335                 u->sent_dbus_new_signal = true;
 336                 return;
 337         }
 338
 339         LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
 340         u->in_dbus_queue = true;
 341 }
 342
 343 static void bidi_set_free(Unit *u, Set *s) {
 344         Iterator i;
 345         Unit *other;
 346
 347         assert(u);
 348
 349         /* Frees the set and makes sure we are dropped from the
 350          * inverse pointers */
 351
 352         SET_FOREACH(other, s, i) {
 353                 UnitDependency d;
 354
 355                 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 356                         set_remove(other->dependencies[d], u);
 357
 358                 unit_add_to_gc_queue(other);
 359         }
 360
 361         set_free(s);
 362 }
 363
 364 static void unit_remove_transient(Unit *u) {
 365         char **i;
 366
 367         assert(u);
 368
 369         if (!u->transient)
 370                 return;
 371
 372         if (u->fragment_path)
 373                 unlink(u->fragment_path);
 374
 375         STRV_FOREACH(i, u->dropin_paths) {
 376                 _cleanup_free_ char *p = NULL;
 377                 int r;
 378
 379                 unlink(*i);
 380
 381                 r = path_get_parent(*i, &p);
 382                 if (r >= 0)
 383                         rmdir(p);
 384         }
 385 }
 386
 387 static void unit_free_requires_mounts_for(Unit *u) {
 388         char **j;
 389
 390         STRV_FOREACH(j, u->requires_mounts_for) {
 391                 char s[strlen(*j) + 1];
 392
 393                 PATH_FOREACH_PREFIX_MORE(s, *j) {
 394                         char *y;
 395                         Set *x;
 396
 397                         x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
 398                         if (!x)
 399                                 continue;
 400
 401                         set_remove(x, u);
 402
 403                         if (set_isempty(x)) {
 404                                 hashmap_remove(u->manager->units_requiring_mounts_for, y);
 405                                 free(y);
 406                                 set_free(x);
 407                         }
 408                 }
 409         }
 410
 411         strv_free(u->requires_mounts_for);
 412         u->requires_mounts_for = NULL;
 413 }
 414
 415 void unit_free(Unit *u) {
 416         UnitDependency d;
 417         Iterator i;
 418         char *t;
 419
 420         assert(u);
 421
 422         if (u->manager->n_reloading <= 0)
 423                 unit_remove_transient(u);
 424
 425         bus_unit_send_removed_signal(u);
 426
 427         if (u->load_state != UNIT_STUB)
 428                 if (UNIT_VTABLE(u)->done)
 429                         UNIT_VTABLE(u)->done(u);
 430
 431         unit_free_requires_mounts_for(u);
 432
 433         SET_FOREACH(t, u->names, i)
 434                 hashmap_remove_value(u->manager->units, t, u);
 435
 436         if (u->job) {
 437                 Job *j = u->job;
 438                 job_uninstall(j);
 439                 job_free(j);
 440         }
 441
 442         if (u->nop_job) {
 443                 Job *j = u->nop_job;
 444                 job_uninstall(j);
 445                 job_free(j);
 446         }
 447
 448         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 449                 bidi_set_free(u, u->dependencies[d]);
 450
 451         if (u->type != _UNIT_TYPE_INVALID)
 452                 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
 453
 454         if (u->in_load_queue)
 455                 LIST_REMOVE(load_queue, u->manager->load_queue, u);
 456
 457         if (u->in_dbus_queue)
 458                 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
 459
 460         if (u->in_cleanup_queue)
 461                 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
 462
 463         if (u->in_gc_queue) {
 464                 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
 465                 u->manager->n_in_gc_queue--;
 466         }
 467
 468         if (u->in_cgroup_queue)
 469                 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
 470
 471         if (u->cgroup_path) {
 472                 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
 473                 free(u->cgroup_path);
 474         }
 475
 476         free(u->description);
 477         strv_free(u->documentation);
 478         free(u->fragment_path);
 479         free(u->source_path);
 480         strv_free(u->dropin_paths);
 481         free(u->instance);
 482
 483         set_free_free(u->names);
 484
 485         unit_unwatch_all_pids(u);
 486
 487         condition_free_list(u->conditions);
 488
 489         unit_ref_unset(&u->slice);
 490
 491         while (u->refs)
 492                 unit_ref_unset(u->refs);
 493
 494         free(u);
 495 }
 496
 497 UnitActiveState unit_active_state(Unit *u) {
 498         assert(u);
 499
 500         if (u->load_state == UNIT_MERGED)
 501                 return unit_active_state(unit_follow_merge(u));
 502
 503         /* After a reload it might happen that a unit is not correctly
 504          * loaded but still has a process around. That's why we won't
 505          * shortcut failed loading to UNIT_INACTIVE_FAILED. */
 506
 507         return UNIT_VTABLE(u)->active_state(u);
 508 }
 509
 510 const char* unit_sub_state_to_string(Unit *u) {
 511         assert(u);
 512
 513         return UNIT_VTABLE(u)->sub_state_to_string(u);
 514 }
 515
 516 static void complete_move(Set **s, Set **other) {
 517         assert(s);
 518         assert(other);
 519
 520         if (!*other)
 521                 return;
 522
 523         if (*s)
 524                 set_move(*s, *other);
 525         else {
 526                 *s = *other;
 527                 *other = NULL;
 528         }
 529 }
 530
 531 static void merge_names(Unit *u, Unit *other) {
 532         char *t;
 533         Iterator i;
 534
 535         assert(u);
 536         assert(other);
 537
 538         complete_move(&u->names, &other->names);
 539
 540         set_free_free(other->names);
 541         other->names = NULL;
 542         other->id = NULL;
 543
 544         SET_FOREACH(t, u->names, i)
 545                 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
 546 }
 547
 548 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
 549         Iterator i;
 550         Unit *back;
 551         int r;
 552
 553         assert(u);
 554         assert(other);
 555         assert(d < _UNIT_DEPENDENCY_MAX);
 556
 557         /* Fix backwards pointers */
 558         SET_FOREACH(back, other->dependencies[d], i) {
 559                 UnitDependency k;
 560
 561                 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
 562                         r = set_remove_and_put(back->dependencies[k], other, u);
 563                         if (r == -EEXIST)
 564                                 set_remove(back->dependencies[k], other);
 565                         else
 566                                 assert(r >= 0 || r == -ENOENT);
 567                 }
 568         }
 569
 570         complete_move(&u->dependencies[d], &other->dependencies[d]);
 571
 572         set_free(other->dependencies[d]);
 573         other->dependencies[d] = NULL;
 574 }
 575
 576 int unit_merge(Unit *u, Unit *other) {
 577         UnitDependency d;
 578
 579         assert(u);
 580         assert(other);
 581         assert(u->manager == other->manager);
 582         assert(u->type != _UNIT_TYPE_INVALID);
 583
 584         other = unit_follow_merge(other);
 585
 586         if (other == u)
 587                 return 0;
 588
 589         if (u->type != other->type)
 590                 return -EINVAL;
 591
 592         if (!u->instance != !other->instance)
 593                 return -EINVAL;
 594
 595         if (other->load_state != UNIT_STUB &&
 596             other->load_state != UNIT_NOT_FOUND)
 597                 return -EEXIST;
 598
 599         if (other->job)
 600                 return -EEXIST;
 601
 602         if (other->nop_job)
 603                 return -EEXIST;
 604
 605         if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
 606                 return -EEXIST;
 607
 608         /* Merge names */
 609         merge_names(u, other);
 610
 611         /* Redirect all references */
 612         while (other->refs)
 613                 unit_ref_set(other->refs, u);
 614
 615         /* Merge dependencies */
 616         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 617                 merge_dependencies(u, other, d);
 618
 619         other->load_state = UNIT_MERGED;
 620         other->merged_into = u;
 621
 622         /* If there is still some data attached to the other node, we
 623          * don't need it anymore, and can free it. */
 624         if (other->load_state != UNIT_STUB)
 625                 if (UNIT_VTABLE(other)->done)
 626                         UNIT_VTABLE(other)->done(other);
 627
 628         unit_add_to_dbus_queue(u);
 629         unit_add_to_cleanup_queue(other);
 630
 631         return 0;
 632 }
 633
 634 int unit_merge_by_name(Unit *u, const char *name) {
 635         Unit *other;
 636         int r;
 637         _cleanup_free_ char *s = NULL;
 638
 639         assert(u);
 640         assert(name);
 641
 642         if (unit_name_is_template(name)) {
 643                 if (!u->instance)
 644                         return -EINVAL;
 645
 646                 s = unit_name_replace_instance(name, u->instance);
 647                 if (!s)
 648                         return -ENOMEM;
 649
 650                 name = s;
 651         }
 652
 653         other = manager_get_unit(u->manager, name);
 654         if (!other)
 655                 r = unit_add_name(u, name);
 656         else
 657                 r = unit_merge(u, other);
 658
 659         return r;
 660 }
 661
 662 Unit* unit_follow_merge(Unit *u) {
 663         assert(u);
 664
 665         while (u->load_state == UNIT_MERGED)
 666                 assert_se(u = u->merged_into);
 667
 668         return u;
 669 }
 670
 671 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
 672         int r;
 673
 674         assert(u);
 675         assert(c);
 676
 677         if (c->working_directory) {
 678                 r = unit_require_mounts_for(u, c->working_directory);
 679                 if (r < 0)
 680                         return r;
 681         }
 682
 683         if (c->root_directory) {
 684                 r = unit_require_mounts_for(u, c->root_directory);
 685                 if (r < 0)
 686                         return r;
 687         }
 688
 689         if (c->std_output != EXEC_OUTPUT_KMSG &&
 690             c->std_output != EXEC_OUTPUT_SYSLOG &&
 691             c->std_output != EXEC_OUTPUT_JOURNAL &&
 692             c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
 693             c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
 694             c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
 695             c->std_error != EXEC_OUTPUT_KMSG &&
 696             c->std_error != EXEC_OUTPUT_SYSLOG &&
 697             c->std_error != EXEC_OUTPUT_JOURNAL &&
 698             c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
 699             c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
 700             c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
 701                 return 0;
 702
 703         /* If syslog or kernel logging is requested, make sure our own
 704          * logging daemon is run first. */
 705
 706         if (u->manager->running_as == SYSTEMD_SYSTEM) {
 707                 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
 708                 if (r < 0)
 709                         return r;
 710         }
 711
 712         return 0;
 713 }
 714
 715 const char *unit_description(Unit *u) {
 716         assert(u);
 717
 718         if (u->description)
 719                 return u->description;
 720
 721         return strna(u->id);
 722 }
 723
 724 void unit_dump(Unit *u, FILE *f, const char *prefix) {
 725         char *t, **j;
 726         UnitDependency d;
 727         Iterator i;
 728         _cleanup_free_ char *p2 = NULL;
 729         const char *prefix2;
 730         char
 731                 timestamp1[FORMAT_TIMESTAMP_MAX],
 732                 timestamp2[FORMAT_TIMESTAMP_MAX],
 733                 timestamp3[FORMAT_TIMESTAMP_MAX],
 734                 timestamp4[FORMAT_TIMESTAMP_MAX],
 735                 timespan[FORMAT_TIMESPAN_MAX];
 736         Unit *following;
 737         _cleanup_set_free_ Set *following_set = NULL;
 738         int r;
 739
 740         assert(u);
 741         assert(u->type >= 0);
 742
 743         if (!prefix)
 744                 prefix = "";
 745         p2 = strappend(prefix, "\t");
 746         prefix2 = p2 ? p2 : prefix;
 747
 748         fprintf(f,
 749                 "%s-> Unit %s:\n"
 750                 "%s\tDescription: %s\n"
 751                 "%s\tInstance: %s\n"
 752                 "%s\tUnit Load State: %s\n"
 753                 "%s\tUnit Active State: %s\n"
 754                 "%s\tInactive Exit Timestamp: %s\n"
 755                 "%s\tActive Enter Timestamp: %s\n"
 756                 "%s\tActive Exit Timestamp: %s\n"
 757                 "%s\tInactive Enter Timestamp: %s\n"
 758                 "%s\tGC Check Good: %s\n"
 759                 "%s\tNeed Daemon Reload: %s\n"
 760                 "%s\tTransient: %s\n"
 761                 "%s\tSlice: %s\n"
 762                 "%s\tCGroup: %s\n"
 763                 "%s\tCGroup realized: %s\n"
 764                 "%s\tCGroup mask: 0x%x\n"
 765                 "%s\tCGroup members mask: 0x%x\n",
 766                 prefix, u->id,
 767                 prefix, unit_description(u),
 768                 prefix, strna(u->instance),
 769                 prefix, unit_load_state_to_string(u->load_state),
 770                 prefix, unit_active_state_to_string(unit_active_state(u)),
 771                 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
 772                 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
 773                 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
 774                 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
 775                 prefix, yes_no(unit_check_gc(u)),
 776                 prefix, yes_no(unit_need_daemon_reload(u)),
 777                 prefix, yes_no(u->transient),
 778                 prefix, strna(unit_slice_name(u)),
 779                 prefix, strna(u->cgroup_path),
 780                 prefix, yes_no(u->cgroup_realized),
 781                 prefix, u->cgroup_realized_mask,
 782                 prefix, u->cgroup_members_mask);
 783
 784         SET_FOREACH(t, u->names, i)
 785                 fprintf(f, "%s\tName: %s\n", prefix, t);
 786
 787         STRV_FOREACH(j, u->documentation)
 788                 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
 789
 790         following = unit_following(u);
 791         if (following)
 792                 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
 793
 794         r = unit_following_set(u, &following_set);
 795         if (r >= 0) {
 796                 Unit *other;
 797
 798                 SET_FOREACH(other, following_set, i)
 799                         fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
 800         }
 801
 802         if (u->fragment_path)
 803                 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
 804
 805         if (u->source_path)
 806                 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
 807
 808         STRV_FOREACH(j, u->dropin_paths)
 809                 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
 810
 811         if (u->job_timeout > 0)
 812                 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
 813
 814         condition_dump_list(u->conditions, f, prefix);
 815
 816         if (dual_timestamp_is_set(&u->condition_timestamp))
 817                 fprintf(f,
 818                         "%s\tCondition Timestamp: %s\n"
 819                         "%s\tCondition Result: %s\n",
 820                         prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
 821                         prefix, yes_no(u->condition_result));
 822
 823         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
 824                 Unit *other;
 825
 826                 SET_FOREACH(other, u->dependencies[d], i)
 827                         fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
 828         }
 829
 830         if (!strv_isempty(u->requires_mounts_for)) {
 831                 fprintf(f,
 832                         "%s\tRequiresMountsFor:", prefix);
 833
 834                 STRV_FOREACH(j, u->requires_mounts_for)
 835                         fprintf(f, " %s", *j);
 836
 837                 fputs("\n", f);
 838         }
 839
 840         if (u->load_state == UNIT_LOADED) {
 841
 842                 fprintf(f,
 843                         "%s\tStopWhenUnneeded: %s\n"
 844                         "%s\tRefuseManualStart: %s\n"
 845                         "%s\tRefuseManualStop: %s\n"
 846                         "%s\tDefaultDependencies: %s\n"
 847                         "%s\tOnFailureJobMode: %s\n"
 848                         "%s\tIgnoreOnIsolate: %s\n"
 849                         "%s\tIgnoreOnSnapshot: %s\n",
 850                         prefix, yes_no(u->stop_when_unneeded),
 851                         prefix, yes_no(u->refuse_manual_start),
 852                         prefix, yes_no(u->refuse_manual_stop),
 853                         prefix, yes_no(u->default_dependencies),
 854                         prefix, job_mode_to_string(u->on_failure_job_mode),
 855                         prefix, yes_no(u->ignore_on_isolate),
 856                         prefix, yes_no(u->ignore_on_snapshot));
 857
 858                 if (UNIT_VTABLE(u)->dump)
 859                         UNIT_VTABLE(u)->dump(u, f, prefix2);
 860
 861         } else if (u->load_state == UNIT_MERGED)
 862                 fprintf(f,
 863                         "%s\tMerged into: %s\n",
 864                         prefix, u->merged_into->id);
 865         else if (u->load_state == UNIT_ERROR)
 866                 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
 867
 868
 869         if (u->job)
 870                 job_dump(u->job, f, prefix2);
 871
 872         if (u->nop_job)
 873                 job_dump(u->nop_job, f, prefix2);
 874
 875 }
 876
 877 /* Common implementation for multiple backends */
 878 int unit_load_fragment_and_dropin(Unit *u) {
 879         int r;
 880
 881         assert(u);
 882
 883         /* Load a .{service,socket,...} file */
 884         r = unit_load_fragment(u);
 885         if (r < 0)
 886                 return r;
 887
 888         if (u->load_state == UNIT_STUB)
 889                 return -ENOENT;
 890
 891         /* Load drop-in directory data */
 892         r = unit_load_dropin(unit_follow_merge(u));
 893         if (r < 0)
 894                 return r;
 895
 896         return 0;
 897 }
 898
 899 /* Common implementation for multiple backends */
 900 int unit_load_fragment_and_dropin_optional(Unit *u) {
 901         int r;
 902
 903         assert(u);
 904
 905         /* Same as unit_load_fragment_and_dropin(), but whether
 906          * something can be loaded or not doesn't matter. */
 907
 908         /* Load a .service file */
 909         r = unit_load_fragment(u);
 910         if (r < 0)
 911                 return r;
 912
 913         if (u->load_state == UNIT_STUB)
 914                 u->load_state = UNIT_LOADED;
 915
 916         /* Load drop-in directory data */
 917         r = unit_load_dropin(unit_follow_merge(u));
 918         if (r < 0)
 919                 return r;
 920
 921         return 0;
 922 }
 923
 924 int unit_add_default_target_dependency(Unit *u, Unit *target) {
 925         assert(u);
 926         assert(target);
 927
 928         if (target->type != UNIT_TARGET)
 929                 return 0;
 930
 931         /* Only add the dependency if both units are loaded, so that
 932          * that loop check below is reliable */
 933         if (u->load_state != UNIT_LOADED ||
 934             target->load_state != UNIT_LOADED)
 935                 return 0;
 936
 937         /* If either side wants no automatic dependencies, then let's
 938          * skip this */
 939         if (!u->default_dependencies ||
 940             !target->default_dependencies)
 941                 return 0;
 942
 943         /* Don't create loops */
 944         if (set_get(target->dependencies[UNIT_BEFORE], u))
 945                 return 0;
 946
 947         return unit_add_dependency(target, UNIT_AFTER, u, true);
 948 }
 949
 950 static int unit_add_target_dependencies(Unit *u) {
 951
 952         static const UnitDependency deps[] = {
 953                 UNIT_REQUIRED_BY,
 954                 UNIT_REQUIRED_BY_OVERRIDABLE,
 955                 UNIT_WANTED_BY,
 956                 UNIT_BOUND_BY
 957         };
 958
 959         Unit *target;
 960         Iterator i;
 961         unsigned k;
 962         int r;
 963
 964         assert(u);
 965
 966         for (k = 0; k < ELEMENTSOF(deps); k++)
 967                 SET_FOREACH(target, u->dependencies[deps[k]], i) {
 968                         r = unit_add_default_target_dependency(u, target);
 969                         if (r < 0)
 970                                 return r;
 971                 }
 972
 973         return r;
 974 }
 975
 976 static int unit_add_slice_dependencies(Unit *u) {
 977         assert(u);
 978
 979         if (!unit_get_cgroup_context(u))
 980                 return 0;
 981
 982         if (UNIT_ISSET(u->slice))
 983                 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
 984
 985         return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
 986 }
 987
 988 static int unit_add_mount_dependencies(Unit *u) {
 989         char **i;
 990         int r;
 991
 992         assert(u);
 993
 994         STRV_FOREACH(i, u->requires_mounts_for) {
 995                 char prefix[strlen(*i) + 1];
 996
 997                 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
 998                         Unit *m;
 999
1000                         r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1001                         if (r < 0)
1002                                 return r;
1003                         if (r == 0)
1004                                 continue;
1005                         if (m == u)
1006                                 continue;
1007
1008                         if (m->load_state != UNIT_LOADED)
1009                                 continue;
1010
1011                         r = unit_add_dependency(u, UNIT_AFTER, m, true);
1012                         if (r < 0)
1013                                 return r;
1014
1015                         if (m->fragment_path) {
1016                                 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1017                                 if (r < 0)
1018                                         return r;
1019                         }
1020                 }
1021         }
1022
1023         return 0;
1024 }
1025
1026 int unit_load(Unit *u) {
1027         int r;
1028
1029         assert(u);
1030
1031         if (u->in_load_queue) {
1032                 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1033                 u->in_load_queue = false;
1034         }
1035
1036         if (u->type == _UNIT_TYPE_INVALID)
1037                 return -EINVAL;
1038
1039         if (u->load_state != UNIT_STUB)
1040                 return 0;
1041
1042         if (UNIT_VTABLE(u)->load) {
1043                 r = UNIT_VTABLE(u)->load(u);
1044                 if (r < 0)
1045                         goto fail;
1046         }
1047
1048         if (u->load_state == UNIT_STUB) {
1049                 r = -ENOENT;
1050                 goto fail;
1051         }
1052
1053         if (u->load_state == UNIT_LOADED) {
1054
1055                 r = unit_add_target_dependencies(u);
1056                 if (r < 0)
1057                         goto fail;
1058
1059                 r = unit_add_slice_dependencies(u);
1060                 if (r < 0)
1061                         goto fail;
1062
1063                 r = unit_add_mount_dependencies(u);
1064                 if (r < 0)
1065                         goto fail;
1066
1067                 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1068                         log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
1069                         r = -EINVAL;
1070                         goto fail;
1071                 }
1072
1073                 unit_update_cgroup_members_masks(u);
1074         }
1075
1076         assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1077
1078         unit_add_to_dbus_queue(unit_follow_merge(u));
1079         unit_add_to_gc_queue(u);
1080
1081         return 0;
1082
1083 fail:
1084         u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1085         u->load_error = r;
1086         unit_add_to_dbus_queue(u);
1087         unit_add_to_gc_queue(u);
1088
1089         log_debug_unit(u->id, "Failed to load configuration for %s: %s",
1090                        u->id, strerror(-r));
1091
1092         return r;
1093 }
1094
1095 static bool unit_condition_test(Unit *u) {
1096         assert(u);
1097
1098         dual_timestamp_get(&u->condition_timestamp);
1099         u->condition_result = condition_test_list(u->id, u->conditions);
1100
1101         return u->condition_result;
1102 }
1103
1104 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1105         const UnitStatusMessageFormats *format_table;
1106
1107         assert(u);
1108         assert(t >= 0);
1109         assert(t < _JOB_TYPE_MAX);
1110
1111         if (t != JOB_START && t != JOB_STOP)
1112                 return NULL;
1113
1114         format_table = &UNIT_VTABLE(u)->status_message_formats;
1115         if (!format_table)
1116                 return NULL;
1117
1118         return format_table->starting_stopping[t == JOB_STOP];
1119 }
1120
1121 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1122         const char *format;
1123
1124         assert(u);
1125         assert(t >= 0);
1126         assert(t < _JOB_TYPE_MAX);
1127
1128         format = unit_get_status_message_format(u, t);
1129         if (format)
1130                 return format;
1131
1132         /* Return generic strings */
1133         if (t == JOB_START)
1134                 return "Starting %s.";
1135         else if (t == JOB_STOP)
1136                 return "Stopping %s.";
1137         else if (t == JOB_RELOAD)
1138                 return "Reloading %s.";
1139
1140         return NULL;
1141 }
1142
1143 #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;
1538
1539                 ec = unit_get_exec_context(u);
1540                 if (ec && exec_context_may_touch_console(ec)) {
1541                         if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1542                                 m->n_on_console --;
1543
1544                                 if (m->n_on_console == 0)
1545                                         /* unset no_console_output flag, since the console is free */
1546                                         m->no_console_output = false;
1547                         } else
1548                                 m->n_on_console ++;
1549                 }
1550         }
1551
1552         if (u->job) {
1553                 unexpected = false;
1554
1555                 if (u->job->state == JOB_WAITING)
1556
1557                         /* So we reached a different state for this
1558                          * job. Let's see if we can run it now if it
1559                          * failed previously due to EAGAIN. */
1560                         job_add_to_run_queue(u->job);
1561
1562                 /* Let's check whether this state change constitutes a
1563                  * finished job, or maybe contradicts a running job and
1564                  * hence needs to invalidate jobs. */
1565
1566                 switch (u->job->type) {
1567
1568                 case JOB_START:
1569                 case JOB_VERIFY_ACTIVE:
1570
1571                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1572                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1573                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1574                                 unexpected = true;
1575
1576                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1577                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1578                         }
1579
1580                         break;
1581
1582                 case JOB_RELOAD:
1583                 case JOB_RELOAD_OR_START:
1584
1585                         if (u->job->state == JOB_RUNNING) {
1586                                 if (ns == UNIT_ACTIVE)
1587                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1588                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1589                                         unexpected = true;
1590
1591                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1592                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1593                                 }
1594                         }
1595
1596                         break;
1597
1598                 case JOB_STOP:
1599                 case JOB_RESTART:
1600                 case JOB_TRY_RESTART:
1601
1602                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1603                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1604                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1605                                 unexpected = true;
1606                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1607                         }
1608
1609                         break;
1610
1611                 default:
1612                         assert_not_reached("Job type unknown");
1613                 }
1614
1615         } else
1616                 unexpected = true;
1617
1618         if (m->n_reloading <= 0) {
1619
1620                 /* If this state change happened without being
1621                  * requested by a job, then let's retroactively start
1622                  * or stop dependencies. We skip that step when
1623                  * deserializing, since we don't want to create any
1624                  * additional jobs just because something is already
1625                  * activated. */
1626
1627                 if (unexpected) {
1628                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1629                                 retroactively_start_dependencies(u);
1630                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1631                                 retroactively_stop_dependencies(u);
1632                 }
1633
1634                 /* stop unneeded units regardless if going down was expected or not */
1635                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1636                         check_unneeded_dependencies(u);
1637
1638                 if (ns != os && ns == UNIT_FAILED) {
1639                         log_notice_unit(u->id, "Unit %s entered failed state.", u->id);
1640                         unit_start_on_failure(u);
1641                 }
1642         }
1643
1644         /* Some names are special */
1645         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1646
1647                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1648                         /* The bus just might have become available,
1649                          * hence try to connect to it, if we aren't
1650                          * yet connected. */
1651                         bus_init(m, true);
1652
1653                 if (u->type == UNIT_SERVICE &&
1654                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1655                     m->n_reloading <= 0) {
1656                         /* Write audit record if we have just finished starting up */
1657                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1658                         u->in_audit = true;
1659                 }
1660
1661                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1662                         manager_send_unit_plymouth(m, u);
1663
1664         } else {
1665
1666                 /* We don't care about D-Bus here, since we'll get an
1667                  * asynchronous notification for it anyway. */
1668
1669                 if (u->type == UNIT_SERVICE &&
1670                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1671                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1672                     m->n_reloading <= 0) {
1673
1674                         /* Hmm, if there was no start record written
1675                          * write it now, so that we always have a nice
1676                          * pair */
1677                         if (!u->in_audit) {
1678                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1679
1680                                 if (ns == UNIT_INACTIVE)
1681                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1682                         } else
1683                                 /* Write audit record if we have just finished shutting down */
1684                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1685
1686                         u->in_audit = false;
1687                 }
1688         }
1689
1690         manager_recheck_journal(m);
1691         unit_trigger_notify(u);
1692
1693         /* Maybe we finished startup and are now ready for being
1694          * stopped because unneeded? */
1695         if (u->manager->n_reloading <= 0)
1696                 unit_check_unneeded(u);
1697
1698         unit_add_to_dbus_queue(u);
1699         unit_add_to_gc_queue(u);
1700 }
1701
1702 int unit_watch_pid(Unit *u, pid_t pid) {
1703         int q, r;
1704
1705         assert(u);
1706         assert(pid >= 1);
1707
1708         /* Watch a specific PID. We only support one or two units
1709          * watching each PID for now, not more. */
1710
1711         r = hashmap_ensure_allocated(&u->manager->watch_pids1, trivial_hash_func, trivial_compare_func);
1712         if (r < 0)
1713                 return r;
1714
1715         r = set_ensure_allocated(&u->pids, trivial_hash_func, trivial_compare_func);
1716         if (r < 0)
1717                 return r;
1718
1719         r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1720         if (r == -EEXIST) {
1721                 r = hashmap_ensure_allocated(&u->manager->watch_pids2, trivial_hash_func, trivial_compare_func);
1722                 if (r < 0)
1723                         return r;
1724
1725                 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1726         }
1727
1728         q = set_put(u->pids, LONG_TO_PTR(pid));
1729         if (q < 0)
1730                 return q;
1731
1732         return r;
1733 }
1734
1735 void unit_unwatch_pid(Unit *u, pid_t pid) {
1736         assert(u);
1737         assert(pid >= 1);
1738
1739         hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1740         hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
1741         set_remove(u->pids, LONG_TO_PTR(pid));
1742 }
1743
1744 static int watch_pids_in_path(Unit *u, const char *path) {
1745         _cleanup_closedir_ DIR *d = NULL;
1746         _cleanup_fclose_ FILE *f = NULL;
1747         int ret = 0, r;
1748
1749         assert(u);
1750         assert(path);
1751
1752         /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
1753
1754         r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
1755         if (r >= 0) {
1756                 pid_t pid;
1757
1758                 while ((r = cg_read_pid(f, &pid)) > 0) {
1759                         r = unit_watch_pid(u, pid);
1760                         if (r < 0 && ret >= 0)
1761                                 ret = r;
1762                 }
1763                 if (r < 0 && ret >= 0)
1764                         ret = r;
1765
1766         } else if (ret >= 0)
1767                 ret = r;
1768
1769         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
1770         if (r >= 0) {
1771                 char *fn;
1772
1773                 while ((r = cg_read_subgroup(d, &fn)) > 0) {
1774                         _cleanup_free_ char *p = NULL;
1775
1776                         p = strjoin(path, "/", fn, NULL);
1777                         free(fn);
1778
1779                         if (!p)
1780                                 return -ENOMEM;
1781
1782                         r = watch_pids_in_path(u, p);
1783                         if (r < 0 && ret >= 0)
1784                                 ret = r;
1785                 }
1786                 if (r < 0 && ret >= 0)
1787                         ret = r;
1788
1789         } else if (ret >= 0)
1790                 ret = r;
1791
1792         return ret;
1793 }
1794
1795
1796 int unit_watch_all_pids(Unit *u) {
1797         assert(u);
1798
1799         if (!u->cgroup_path)
1800                 return -ENOENT;
1801
1802         /* Adds all PIDs from our cgroup to the set of PIDs we watch */
1803
1804         return watch_pids_in_path(u, u->cgroup_path);
1805 }
1806
1807 void unit_unwatch_all_pids(Unit *u) {
1808         Iterator i;
1809         void *e;
1810
1811         assert(u);
1812
1813         SET_FOREACH(e, u->pids, i) {
1814                 hashmap_remove_value(u->manager->watch_pids1, e, u);
1815                 hashmap_remove_value(u->manager->watch_pids2, e, u);
1816         }
1817
1818         set_free(u->pids);
1819         u->pids = NULL;
1820 }
1821
1822 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
1823         Iterator i;
1824         void *e;
1825
1826         assert(u);
1827
1828         /* Cleans dead PIDs from our list */
1829
1830         SET_FOREACH(e, u->pids, i) {
1831                 pid_t pid = PTR_TO_LONG(e);
1832
1833                 if (pid == except1 || pid == except2)
1834                         continue;
1835
1836                 if (!pid_is_unwaited(pid))
1837                         set_remove(u->pids, e);
1838         }
1839 }
1840
1841 bool unit_job_is_applicable(Unit *u, JobType j) {
1842         assert(u);
1843         assert(j >= 0 && j < _JOB_TYPE_MAX);
1844
1845         switch (j) {
1846
1847         case JOB_VERIFY_ACTIVE:
1848         case JOB_START:
1849         case JOB_STOP:
1850         case JOB_NOP:
1851                 return true;
1852
1853         case JOB_RESTART:
1854         case JOB_TRY_RESTART:
1855                 return unit_can_start(u);
1856
1857         case JOB_RELOAD:
1858                 return unit_can_reload(u);
1859
1860         case JOB_RELOAD_OR_START:
1861                 return unit_can_reload(u) && unit_can_start(u);
1862
1863         default:
1864                 assert_not_reached("Invalid job type");
1865         }
1866 }
1867
1868 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1869
1870         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1871                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1872                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1873                 [UNIT_WANTS] = UNIT_WANTED_BY,
1874                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1875                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1876                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1877                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1878                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1879                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1880                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1881                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1882                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1883                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1884                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1885                 [UNIT_BEFORE] = UNIT_AFTER,
1886                 [UNIT_AFTER] = UNIT_BEFORE,
1887                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1888                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1889                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1890                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1891                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1892                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1893                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1894                 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
1895         };
1896         int r, q = 0, v = 0, w = 0;
1897
1898         assert(u);
1899         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1900         assert(other);
1901
1902         u = unit_follow_merge(u);
1903         other = unit_follow_merge(other);
1904
1905         /* We won't allow dependencies on ourselves. We will not
1906          * consider them an error however. */
1907         if (u == other)
1908                 return 0;
1909
1910         r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func);
1911         if (r < 0)
1912                 return r;
1913
1914         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
1915                 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func);
1916                 if (r < 0)
1917                         return r;
1918         }
1919
1920         if (add_reference) {
1921                 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func);
1922                 if (r < 0)
1923                         return r;
1924
1925                 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func);
1926                 if (r < 0)
1927                         return r;
1928         }
1929
1930         q = set_put(u->dependencies[d], other);
1931         if (q < 0)
1932                 return q;
1933
1934         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
1935                 v = set_put(other->dependencies[inverse_table[d]], u);
1936                 if (v < 0) {
1937                         r = v;
1938                         goto fail;
1939                 }
1940         }
1941
1942         if (add_reference) {
1943                 w = set_put(u->dependencies[UNIT_REFERENCES], other);
1944                 if (w < 0) {
1945                         r = w;
1946                         goto fail;
1947                 }
1948
1949                 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
1950                 if (r < 0)
1951                         goto fail;
1952         }
1953
1954         unit_add_to_dbus_queue(u);
1955         return 0;
1956
1957 fail:
1958         if (q > 0)
1959                 set_remove(u->dependencies[d], other);
1960
1961         if (v > 0)
1962                 set_remove(other->dependencies[inverse_table[d]], u);
1963
1964         if (w > 0)
1965                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1966
1967         return r;
1968 }
1969
1970 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1971         int r;
1972
1973         assert(u);
1974
1975         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1976                 return r;
1977
1978         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1979                 return r;
1980
1981         return 0;
1982 }
1983
1984 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1985         char *s;
1986
1987         assert(u);
1988         assert(name || path);
1989         assert(p);
1990
1991         if (!name)
1992                 name = basename(path);
1993
1994         if (!unit_name_is_template(name)) {
1995                 *p = NULL;
1996                 return name;
1997         }
1998
1999         if (u->instance)
2000                 s = unit_name_replace_instance(name, u->instance);
2001         else {
2002                 _cleanup_free_ char *i = NULL;
2003
2004                 i = unit_name_to_prefix(u->id);
2005                 if (!i)
2006                         return NULL;
2007
2008                 s = unit_name_replace_instance(name, i);
2009         }
2010
2011         if (!s)
2012                 return NULL;
2013
2014         *p = s;
2015         return s;
2016 }
2017
2018 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2019         Unit *other;
2020         int r;
2021         _cleanup_free_ char *s = NULL;
2022
2023         assert(u);
2024         assert(name || path);
2025
2026         name = resolve_template(u, name, path, &s);
2027         if (!name)
2028                 return -ENOMEM;
2029
2030         r = manager_load_unit(u->manager, name, path, NULL, &other);
2031         if (r < 0)
2032                 return r;
2033
2034         return unit_add_dependency(u, d, other, add_reference);
2035 }
2036
2037 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2038         Unit *other;
2039         int r;
2040         _cleanup_free_ char *s = NULL;
2041
2042         assert(u);
2043         assert(name || path);
2044
2045         if (!(name = resolve_template(u, name, path, &s)))
2046                 return -ENOMEM;
2047
2048         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2049                 return r;
2050
2051         r = unit_add_two_dependencies(u, d, e, other, add_reference);
2052
2053         return r;
2054 }
2055
2056 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2057         Unit *other;
2058         int r;
2059         _cleanup_free_ char *s = NULL;
2060
2061         assert(u);
2062         assert(name || path);
2063
2064         if (!(name = resolve_template(u, name, path, &s)))
2065                 return -ENOMEM;
2066
2067         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2068                 return r;
2069
2070         r = unit_add_dependency(other, d, u, add_reference);
2071
2072         return r;
2073 }
2074
2075 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2076         Unit *other;
2077         int r;
2078         _cleanup_free_ char *s = NULL;
2079
2080         assert(u);
2081         assert(name || path);
2082
2083         if (!(name = resolve_template(u, name, path, &s)))
2084                 return -ENOMEM;
2085
2086         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2087                 return r;
2088
2089         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2090                 return r;
2091
2092         return r;
2093 }
2094
2095 int set_unit_path(const char *p) {
2096         _cleanup_free_ char *c = NULL;
2097
2098         /* This is mostly for debug purposes */
2099         c = path_make_absolute_cwd(p);
2100         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2101                 return -errno;
2102
2103         return 0;
2104 }
2105
2106 char *unit_dbus_path(Unit *u) {
2107         assert(u);
2108
2109         if (!u->id)
2110                 return NULL;
2111
2112         return unit_dbus_path_from_name(u->id);
2113 }
2114
2115 char *unit_default_cgroup_path(Unit *u) {
2116         _cleanup_free_ char *escaped = NULL, *slice = NULL;
2117         int r;
2118
2119         assert(u);
2120
2121         if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2122                 return strdup(u->manager->cgroup_root);
2123
2124         if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2125                 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2126                 if (r < 0)
2127                         return NULL;
2128         }
2129
2130         escaped = cg_escape(u->id);
2131         if (!escaped)
2132                 return NULL;
2133
2134         if (slice)
2135                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2136         else
2137                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2138 }
2139
2140 int unit_add_default_slice(Unit *u) {
2141         _cleanup_free_ char *b = NULL;
2142         const char *slice_name;
2143         Unit *slice;
2144         int r;
2145
2146         assert(u);
2147
2148         if (UNIT_ISSET(u->slice))
2149                 return 0;
2150
2151         if (!unit_get_cgroup_context(u))
2152                 return 0;
2153
2154         if (u->instance) {
2155                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2156
2157                 /* Implicitly place all instantiated units in their
2158                  * own per-template slice */
2159
2160                 prefix = unit_name_to_prefix(u->id);
2161                 if (!prefix)
2162                         return -ENOMEM;
2163
2164                 /* The prefix is already escaped, but it might include
2165                  * "-" which has a special meaning for slice units,
2166                  * hence escape it here extra. */
2167                 escaped = strreplace(prefix, "-", "\\x2d");
2168                 if (!escaped)
2169                         return -ENOMEM;
2170
2171                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2172                         b = strjoin("system-", escaped, ".slice", NULL);
2173                 else
2174                         b = strappend(escaped, ".slice");
2175                 if (!b)
2176                         return -ENOMEM;
2177
2178                 slice_name = b;
2179         } else
2180                 slice_name =
2181                         u->manager->running_as == SYSTEMD_SYSTEM
2182                         ? SPECIAL_SYSTEM_SLICE
2183                         : SPECIAL_ROOT_SLICE;
2184
2185         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2186         if (r < 0)
2187                 return r;
2188
2189         unit_ref_set(&u->slice, slice);
2190         return 0;
2191 }
2192
2193 const char *unit_slice_name(Unit *u) {
2194         assert(u);
2195
2196         if (!UNIT_ISSET(u->slice))
2197                 return NULL;
2198
2199         return UNIT_DEREF(u->slice)->id;
2200 }
2201
2202 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2203         _cleanup_free_ char *t = NULL;
2204         int r;
2205
2206         assert(u);
2207         assert(type);
2208         assert(_found);
2209
2210         t = unit_name_change_suffix(u->id, type);
2211         if (!t)
2212                 return -ENOMEM;
2213
2214         assert(!unit_has_name(u, t));
2215
2216         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2217         assert(r < 0 || *_found != u);
2218         return r;
2219 }
2220
2221 int unit_watch_bus_name(Unit *u, const char *name) {
2222         assert(u);
2223         assert(name);
2224
2225         /* Watch a specific name on the bus. We only support one unit
2226          * watching each name for now. */
2227
2228         return hashmap_put(u->manager->watch_bus, name, u);
2229 }
2230
2231 void unit_unwatch_bus_name(Unit *u, const char *name) {
2232         assert(u);
2233         assert(name);
2234
2235         hashmap_remove_value(u->manager->watch_bus, name, u);
2236 }
2237
2238 bool unit_can_serialize(Unit *u) {
2239         assert(u);
2240
2241         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2242 }
2243
2244 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2245         ExecRuntime *rt;
2246         int r;
2247
2248         assert(u);
2249         assert(f);
2250         assert(fds);
2251
2252         if (!unit_can_serialize(u))
2253                 return 0;
2254
2255         r = UNIT_VTABLE(u)->serialize(u, f, fds);
2256         if (r < 0)
2257                 return r;
2258
2259         rt = unit_get_exec_runtime(u);
2260         if (rt) {
2261                 r = exec_runtime_serialize(rt, u, f, fds);
2262                 if (r < 0)
2263                         return r;
2264         }
2265
2266         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2267         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2268         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2269         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2270         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2271
2272         if (dual_timestamp_is_set(&u->condition_timestamp))
2273                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2274
2275         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2276
2277         if (u->cgroup_path)
2278                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2279
2280         if (serialize_jobs) {
2281                 if (u->job) {
2282                         fprintf(f, "job\n");
2283                         job_serialize(u->job, f, fds);
2284                 }
2285
2286                 if (u->nop_job) {
2287                         fprintf(f, "job\n");
2288                         job_serialize(u->nop_job, f, fds);
2289                 }
2290         }
2291
2292         /* End marker */
2293         fputc('\n', f);
2294         return 0;
2295 }
2296
2297 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2298         va_list ap;
2299
2300         assert(u);
2301         assert(f);
2302         assert(key);
2303         assert(format);
2304
2305         fputs(key, f);
2306         fputc('=', f);
2307
2308         va_start(ap, format);
2309         vfprintf(f, format, ap);
2310         va_end(ap);
2311
2312         fputc('\n', f);
2313 }
2314
2315 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2316         assert(u);
2317         assert(f);
2318         assert(key);
2319         assert(value);
2320
2321         fprintf(f, "%s=%s\n", key, value);
2322 }
2323
2324 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2325         size_t offset;
2326         ExecRuntime **rt = NULL;
2327         int r;
2328
2329         assert(u);
2330         assert(f);
2331         assert(fds);
2332
2333         if (!unit_can_serialize(u))
2334                 return 0;
2335
2336         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2337         if (offset > 0)
2338                 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2339
2340         for (;;) {
2341                 char line[LINE_MAX], *l, *v;
2342                 size_t k;
2343
2344                 if (!fgets(line, sizeof(line), f)) {
2345                         if (feof(f))
2346                                 return 0;
2347                         return -errno;
2348                 }
2349
2350                 char_array_0(line);
2351                 l = strstrip(line);
2352
2353                 /* End marker */
2354                 if (l[0] == 0)
2355                         return 0;
2356
2357                 k = strcspn(l, "=");
2358
2359                 if (l[k] == '=') {
2360                         l[k] = 0;
2361                         v = l+k+1;
2362                 } else
2363                         v = l+k;
2364
2365                 if (streq(l, "job")) {
2366                         if (v[0] == '\0') {
2367                                 /* new-style serialized job */
2368                                 Job *j = job_new_raw(u);
2369                                 if (!j)
2370                                         return -ENOMEM;
2371
2372                                 r = job_deserialize(j, f, fds);
2373                                 if (r < 0) {
2374                                         job_free(j);
2375                                         return r;
2376                                 }
2377
2378                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2379                                 if (r < 0) {
2380                                         job_free(j);
2381                                         return r;
2382                                 }
2383
2384                                 r = job_install_deserialized(j);
2385                                 if (r < 0) {
2386                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2387                                         job_free(j);
2388                                         return r;
2389                                 }
2390
2391                                 if (j->state == JOB_RUNNING)
2392                                         u->manager->n_running_jobs++;
2393                         } else {
2394                                 /* legacy */
2395                                 JobType type = job_type_from_string(v);
2396                                 if (type < 0)
2397                                         log_debug("Failed to parse job type value %s", v);
2398                                 else
2399                                         u->deserialized_job = type;
2400                         }
2401                         continue;
2402                 } else if (streq(l, "inactive-exit-timestamp")) {
2403                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2404                         continue;
2405                 } else if (streq(l, "active-enter-timestamp")) {
2406                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2407                         continue;
2408                 } else if (streq(l, "active-exit-timestamp")) {
2409                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2410                         continue;
2411                 } else if (streq(l, "inactive-enter-timestamp")) {
2412                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2413                         continue;
2414                 } else if (streq(l, "condition-timestamp")) {
2415                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2416                         continue;
2417                 } else if (streq(l, "condition-result")) {
2418                         int b;
2419
2420                         b = parse_boolean(v);
2421                         if (b < 0)
2422                                 log_debug("Failed to parse condition result value %s", v);
2423                         else
2424                                 u->condition_result = b;
2425
2426                         continue;
2427
2428                 } else if (streq(l, "transient")) {
2429                         int b;
2430
2431                         b = parse_boolean(v);
2432                         if (b < 0)
2433                                 log_debug("Failed to parse transient bool %s", v);
2434                         else
2435                                 u->transient = b;
2436
2437                         continue;
2438                 } else if (streq(l, "cgroup")) {
2439                         char *s;
2440
2441                         s = strdup(v);
2442                         if (!s)
2443                                 return -ENOMEM;
2444
2445                         free(u->cgroup_path);
2446                         u->cgroup_path = s;
2447
2448                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2449                         continue;
2450                 }
2451
2452                 if (rt) {
2453                         r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2454                         if (r < 0)
2455                                 return r;
2456                         if (r > 0)
2457                                 continue;
2458                 }
2459
2460                 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2461                 if (r < 0)
2462                         return r;
2463         }
2464 }
2465
2466 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2467         Unit *device;
2468         _cleanup_free_ char *e = NULL;
2469         int r;
2470
2471         assert(u);
2472
2473         if (!what)
2474                 return 0;
2475
2476         /* Adds in links to the device node that this unit is based on */
2477
2478         if (!is_device_path(what))
2479                 return 0;
2480
2481         e = unit_name_from_path(what, ".device");
2482         if (!e)
2483                 return -ENOMEM;
2484
2485         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2486
2487         if (r < 0)
2488                 return r;
2489
2490         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2491         if (r < 0)
2492                 return r;
2493
2494         if (wants) {
2495                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2496                 if (r < 0)
2497                         return r;
2498         }
2499
2500         return 0;
2501 }
2502
2503 int unit_coldplug(Unit *u) {
2504         int r;
2505
2506         assert(u);
2507
2508         if (UNIT_VTABLE(u)->coldplug)
2509                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2510                         return r;
2511
2512         if (u->job) {
2513                 r = job_coldplug(u->job);
2514                 if (r < 0)
2515                         return r;
2516         } else if (u->deserialized_job >= 0) {
2517                 /* legacy */
2518                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2519                 if (r < 0)
2520                         return r;
2521
2522                 u->deserialized_job = _JOB_TYPE_INVALID;
2523         }
2524
2525         return 0;
2526 }
2527
2528 #pragma GCC diagnostic push
2529 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2530 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2531         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2532 }
2533 #pragma GCC diagnostic pop
2534
2535 bool unit_need_daemon_reload(Unit *u) {
2536         _cleanup_strv_free_ char **t = NULL;
2537         char **path;
2538         struct stat st;
2539         unsigned loaded_cnt, current_cnt;
2540
2541         assert(u);
2542
2543         if (u->fragment_path) {
2544                 zero(st);
2545                 if (stat(u->fragment_path, &st) < 0)
2546                         /* What, cannot access this anymore? */
2547                         return true;
2548
2549                 if (u->fragment_mtime > 0 &&
2550                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2551                         return true;
2552         }
2553
2554         if (u->source_path) {
2555                 zero(st);
2556                 if (stat(u->source_path, &st) < 0)
2557                         return true;
2558
2559                 if (u->source_mtime > 0 &&
2560                     timespec_load(&st.st_mtim) != u->source_mtime)
2561                         return true;
2562         }
2563
2564         t = unit_find_dropin_paths(u);
2565         loaded_cnt = strv_length(t);
2566         current_cnt = strv_length(u->dropin_paths);
2567
2568         if (loaded_cnt == current_cnt) {
2569                 if (loaded_cnt == 0)
2570                         return false;
2571
2572                 if (strv_overlap(u->dropin_paths, t)) {
2573                         STRV_FOREACH(path, u->dropin_paths) {
2574                                 zero(st);
2575                                 if (stat(*path, &st) < 0)
2576                                         return true;
2577
2578                                 if (u->dropin_mtime > 0 &&
2579                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2580                                         return true;
2581                         }
2582
2583                         return false;
2584                 } else
2585                         return true;
2586         } else
2587                 return true;
2588 }
2589
2590 void unit_reset_failed(Unit *u) {
2591         assert(u);
2592
2593         if (UNIT_VTABLE(u)->reset_failed)
2594                 UNIT_VTABLE(u)->reset_failed(u);
2595 }
2596
2597 Unit *unit_following(Unit *u) {
2598         assert(u);
2599
2600         if (UNIT_VTABLE(u)->following)
2601                 return UNIT_VTABLE(u)->following(u);
2602
2603         return NULL;
2604 }
2605
2606 bool unit_stop_pending(Unit *u) {
2607         assert(u);
2608
2609         /* This call does check the current state of the unit. It's
2610          * hence useful to be called from state change calls of the
2611          * unit itself, where the state isn't updated yet. This is
2612          * different from unit_inactive_or_pending() which checks both
2613          * the current state and for a queued job. */
2614
2615         return u->job && u->job->type == JOB_STOP;
2616 }
2617
2618 bool unit_inactive_or_pending(Unit *u) {
2619         assert(u);
2620
2621         /* Returns true if the unit is inactive or going down */
2622
2623         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2624                 return true;
2625
2626         if (unit_stop_pending(u))
2627                 return true;
2628
2629         return false;
2630 }
2631
2632 bool unit_active_or_pending(Unit *u) {
2633         assert(u);
2634
2635         /* Returns true if the unit is active or going up */
2636
2637         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2638                 return true;
2639
2640         if (u->job &&
2641             (u->job->type == JOB_START ||
2642              u->job->type == JOB_RELOAD_OR_START ||
2643              u->job->type == JOB_RESTART))
2644                 return true;
2645
2646         return false;
2647 }
2648
2649 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2650         assert(u);
2651         assert(w >= 0 && w < _KILL_WHO_MAX);
2652         assert(signo > 0);
2653         assert(signo < _NSIG);
2654
2655         if (!UNIT_VTABLE(u)->kill)
2656                 return -ENOTSUP;
2657
2658         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2659 }
2660
2661 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2662         Set *pid_set;
2663         int r;
2664
2665         pid_set = set_new(trivial_hash_func, trivial_compare_func);
2666         if (!pid_set)
2667                 return NULL;
2668
2669         /* Exclude the main/control pids from being killed via the cgroup */
2670         if (main_pid > 0) {
2671                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2672                 if (r < 0)
2673                         goto fail;
2674         }
2675
2676         if (control_pid > 0) {
2677                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2678                 if (r < 0)
2679                         goto fail;
2680         }
2681
2682         return pid_set;
2683
2684 fail:
2685         set_free(pid_set);
2686         return NULL;
2687 }
2688
2689 int unit_kill_common(
2690                 Unit *u,
2691                 KillWho who,
2692                 int signo,
2693                 pid_t main_pid,
2694                 pid_t control_pid,
2695                 sd_bus_error *error) {
2696
2697         int r = 0;
2698
2699         if (who == KILL_MAIN && main_pid <= 0) {
2700                 if (main_pid < 0)
2701                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2702                 else
2703                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2704                 return -ESRCH;
2705         }
2706
2707         if (who == KILL_CONTROL && control_pid <= 0) {
2708                 if (control_pid < 0)
2709                         sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2710                 else
2711                         sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2712                 return -ESRCH;
2713         }
2714
2715         if (who == KILL_CONTROL || who == KILL_ALL)
2716                 if (control_pid > 0)
2717                         if (kill(control_pid, signo) < 0)
2718                                 r = -errno;
2719
2720         if (who == KILL_MAIN || who == KILL_ALL)
2721                 if (main_pid > 0)
2722                         if (kill(main_pid, signo) < 0)
2723                                 r = -errno;
2724
2725         if (who == KILL_ALL && u->cgroup_path) {
2726                 _cleanup_set_free_ Set *pid_set = NULL;
2727                 int q;
2728
2729                 /* Exclude the main/control pids from being killed via the cgroup */
2730                 pid_set = unit_pid_set(main_pid, control_pid);
2731                 if (!pid_set)
2732                         return -ENOMEM;
2733
2734                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2735                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2736                         r = q;
2737         }
2738
2739         return r;
2740 }
2741
2742 int unit_following_set(Unit *u, Set **s) {
2743         assert(u);
2744         assert(s);
2745
2746         if (UNIT_VTABLE(u)->following_set)
2747                 return UNIT_VTABLE(u)->following_set(u, s);
2748
2749         *s = NULL;
2750         return 0;
2751 }
2752
2753 UnitFileState unit_get_unit_file_state(Unit *u) {
2754         assert(u);
2755
2756         if (u->unit_file_state < 0 && u->fragment_path)
2757                 u->unit_file_state = unit_file_get_state(
2758                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2759                                 NULL, basename(u->fragment_path));
2760
2761         return u->unit_file_state;
2762 }
2763
2764 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2765         assert(ref);
2766         assert(u);
2767
2768         if (ref->unit)
2769                 unit_ref_unset(ref);
2770
2771         ref->unit = u;
2772         LIST_PREPEND(refs, u->refs, ref);
2773         return u;
2774 }
2775
2776 void unit_ref_unset(UnitRef *ref) {
2777         assert(ref);
2778
2779         if (!ref->unit)
2780                 return;
2781
2782         LIST_REMOVE(refs, ref->unit->refs, ref);
2783         ref->unit = NULL;
2784 }
2785
2786 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2787         unsigned i;
2788         int r;
2789
2790         assert(u);
2791         assert(c);
2792
2793         /* This only copies in the ones that need memory */
2794         for (i = 0; i < RLIMIT_NLIMITS; i++)
2795                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2796                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2797                         if (!c->rlimit[i])
2798                                 return -ENOMEM;
2799                 }
2800
2801         if (u->manager->running_as == SYSTEMD_USER &&
2802             !c->working_directory) {
2803
2804                 r = get_home_dir(&c->working_directory);
2805                 if (r < 0)
2806                         return r;
2807         }
2808
2809         return 0;
2810 }
2811
2812 ExecContext *unit_get_exec_context(Unit *u) {
2813         size_t offset;
2814         assert(u);
2815
2816         offset = UNIT_VTABLE(u)->exec_context_offset;
2817         if (offset <= 0)
2818                 return NULL;
2819
2820         return (ExecContext*) ((uint8_t*) u + offset);
2821 }
2822
2823 KillContext *unit_get_kill_context(Unit *u) {
2824         size_t offset;
2825         assert(u);
2826
2827         offset = UNIT_VTABLE(u)->kill_context_offset;
2828         if (offset <= 0)
2829                 return NULL;
2830
2831         return (KillContext*) ((uint8_t*) u + offset);
2832 }
2833
2834 CGroupContext *unit_get_cgroup_context(Unit *u) {
2835         size_t offset;
2836
2837         offset = UNIT_VTABLE(u)->cgroup_context_offset;
2838         if (offset <= 0)
2839                 return NULL;
2840
2841         return (CGroupContext*) ((uint8_t*) u + offset);
2842 }
2843
2844 ExecRuntime *unit_get_exec_runtime(Unit *u) {
2845         size_t offset;
2846
2847         offset = UNIT_VTABLE(u)->exec_runtime_offset;
2848         if (offset <= 0)
2849                 return NULL;
2850
2851         return *(ExecRuntime**) ((uint8_t*) u + offset);
2852 }
2853
2854 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2855         _cleanup_free_ char *b = NULL;
2856         char *p, *q;
2857         int r;
2858
2859         assert(u);
2860         assert(name);
2861         assert(_p);
2862         assert(_q);
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 && !u->transient)
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 (!IN_SET(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 (!IN_SET(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 (!IN_SET(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 (!IN_SET(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 (!IN_SET(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);