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