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