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         /* Note that this doesn't apply to RemainAfterExit services exiting
1494          * sucessfully, since there's no change of state in that case. Which is
1495          * why it is handled in service_set_state() */
1496         if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1497                 ExecContext *ec = unit_get_exec_context(u);
1498                 if (ec && exec_context_may_touch_console(ec)) {
1499                         if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1500                                 m->n_on_console --;
1501
1502                                 if (m->n_on_console == 0)
1503                                         /* unset no_console_output flag, since the console is free */
1504                                         m->no_console_output = false;
1505                         } else
1506                                 m->n_on_console ++;
1507                 }
1508         }
1509
1510         if (u->job) {
1511                 unexpected = false;
1512
1513                 if (u->job->state == JOB_WAITING)
1514
1515                         /* So we reached a different state for this
1516                          * job. Let's see if we can run it now if it
1517                          * failed previously due to EAGAIN. */
1518                         job_add_to_run_queue(u->job);
1519
1520                 /* Let's check whether this state change constitutes a
1521                  * finished job, or maybe contradicts a running job and
1522                  * hence needs to invalidate jobs. */
1523
1524                 switch (u->job->type) {
1525
1526                 case JOB_START:
1527                 case JOB_VERIFY_ACTIVE:
1528
1529                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1530                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1531                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1532                                 unexpected = true;
1533
1534                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1535                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1536                         }
1537
1538                         break;
1539
1540                 case JOB_RELOAD:
1541                 case JOB_RELOAD_OR_START:
1542
1543                         if (u->job->state == JOB_RUNNING) {
1544                                 if (ns == UNIT_ACTIVE)
1545                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1546                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1547                                         unexpected = true;
1548
1549                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1550                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1551                                 }
1552                         }
1553
1554                         break;
1555
1556                 case JOB_STOP:
1557                 case JOB_RESTART:
1558                 case JOB_TRY_RESTART:
1559
1560                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1561                                 job_finish_and_invalidate(u->job, JOB_DONE, true);
1562                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1563                                 unexpected = true;
1564                                 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1565                         }
1566
1567                         break;
1568
1569                 default:
1570                         assert_not_reached("Job type unknown");
1571                 }
1572
1573         } else
1574                 unexpected = true;
1575
1576         if (m->n_reloading <= 0) {
1577
1578                 /* If this state change happened without being
1579                  * requested by a job, then let's retroactively start
1580                  * or stop dependencies. We skip that step when
1581                  * deserializing, since we don't want to create any
1582                  * additional jobs just because something is already
1583                  * activated. */
1584
1585                 if (unexpected) {
1586                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1587                                 retroactively_start_dependencies(u);
1588                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1589                                 retroactively_stop_dependencies(u);
1590                 }
1591
1592                 /* stop unneeded units regardless if going down was expected or not */
1593                 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1594                         check_unneeded_dependencies(u);
1595
1596                 if (ns != os && ns == UNIT_FAILED) {
1597                         log_notice_unit(u->id,
1598                                         "Unit %s entered failed state.", u->id);
1599                         unit_start_on_failure(u);
1600                 }
1601         }
1602
1603         /* Some names are special */
1604         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1605
1606                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1607                         /* The bus just might have become available,
1608                          * hence try to connect to it, if we aren't
1609                          * yet connected. */
1610                         bus_init(m, true);
1611
1612                 if (u->type == UNIT_SERVICE &&
1613                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1614                     m->n_reloading <= 0) {
1615                         /* Write audit record if we have just finished starting up */
1616                         manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1617                         u->in_audit = true;
1618                 }
1619
1620                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1621                         manager_send_unit_plymouth(m, u);
1622
1623         } else {
1624
1625                 /* We don't care about D-Bus here, since we'll get an
1626                  * asynchronous notification for it anyway. */
1627
1628                 if (u->type == UNIT_SERVICE &&
1629                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1630                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1631                     m->n_reloading <= 0) {
1632
1633                         /* Hmm, if there was no start record written
1634                          * write it now, so that we always have a nice
1635                          * pair */
1636                         if (!u->in_audit) {
1637                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1638
1639                                 if (ns == UNIT_INACTIVE)
1640                                         manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1641                         } else
1642                                 /* Write audit record if we have just finished shutting down */
1643                                 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1644
1645                         u->in_audit = false;
1646                 }
1647         }
1648
1649         manager_recheck_journal(m);
1650         unit_trigger_notify(u);
1651
1652         /* Maybe we finished startup and are now ready for being
1653          * stopped because unneeded? */
1654         if (u->manager->n_reloading <= 0)
1655                 unit_check_unneeded(u);
1656
1657         unit_add_to_dbus_queue(u);
1658         unit_add_to_gc_queue(u);
1659 }
1660
1661 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1662         struct epoll_event ev = {
1663                 .data.ptr = w,
1664                 .events = events,
1665         };
1666
1667         assert(u);
1668         assert(fd >= 0);
1669         assert(w);
1670         assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1671
1672         if (epoll_ctl(u->manager->epoll_fd,
1673                       w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1674                       fd,
1675                       &ev) < 0)
1676                 return -errno;
1677
1678         w->fd = fd;
1679         w->type = WATCH_FD;
1680         w->data.unit = u;
1681
1682         return 0;
1683 }
1684
1685 void unit_unwatch_fd(Unit *u, Watch *w) {
1686         assert(u);
1687         assert(w);
1688
1689         if (w->type == WATCH_INVALID)
1690                 return;
1691
1692         assert(w->type == WATCH_FD);
1693         assert(w->data.unit == u);
1694         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1695
1696         w->fd = -1;
1697         w->type = WATCH_INVALID;
1698         w->data.unit = NULL;
1699 }
1700
1701 int unit_watch_pid(Unit *u, pid_t pid) {
1702         assert(u);
1703         assert(pid >= 1);
1704
1705         /* Watch a specific PID. We only support one unit watching
1706          * each PID for now. */
1707
1708         return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1709 }
1710
1711 void unit_unwatch_pid(Unit *u, pid_t pid) {
1712         assert(u);
1713         assert(pid >= 1);
1714
1715         hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1716 }
1717
1718 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1719         struct itimerspec its = {};
1720         int flags, fd;
1721         bool ours;
1722
1723         assert(u);
1724         assert(w);
1725         assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1726
1727         /* This will try to reuse the old timer if there is one */
1728
1729         if (w->type == WATCH_UNIT_TIMER) {
1730                 assert(w->data.unit == u);
1731                 assert(w->fd >= 0);
1732
1733                 ours = false;
1734                 fd = w->fd;
1735         } else if (w->type == WATCH_INVALID) {
1736
1737                 ours = true;
1738                 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1739                 if (fd < 0)
1740                         return -errno;
1741         } else
1742                 assert_not_reached("Invalid watch type");
1743
1744         if (usec <= 0) {
1745                 /* Set absolute time in the past, but not 0, since we
1746                  * don't want to disarm the timer */
1747                 its.it_value.tv_sec = 0;
1748                 its.it_value.tv_nsec = 1;
1749
1750                 flags = TFD_TIMER_ABSTIME;
1751         } else {
1752                 timespec_store(&its.it_value, usec);
1753                 flags = relative ? 0 : TFD_TIMER_ABSTIME;
1754         }
1755
1756         /* This will also flush the elapse counter */
1757         if (timerfd_settime(fd, flags, &its, NULL) < 0)
1758                 goto fail;
1759
1760         if (w->type == WATCH_INVALID) {
1761                 struct epoll_event ev = {
1762                         .data.ptr = w,
1763                         .events = EPOLLIN,
1764                 };
1765
1766                 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1767                         goto fail;
1768         }
1769
1770         w->type = WATCH_UNIT_TIMER;
1771         w->fd = fd;
1772         w->data.unit = u;
1773
1774         return 0;
1775
1776 fail:
1777         if (ours)
1778                 close_nointr_nofail(fd);
1779
1780         return -errno;
1781 }
1782
1783 void unit_unwatch_timer(Unit *u, Watch *w) {
1784         assert(u);
1785         assert(w);
1786
1787         if (w->type == WATCH_INVALID)
1788                 return;
1789
1790         assert(w->type == WATCH_UNIT_TIMER);
1791         assert(w->data.unit == u);
1792         assert(w->fd >= 0);
1793
1794         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1795         close_nointr_nofail(w->fd);
1796
1797         w->fd = -1;
1798         w->type = WATCH_INVALID;
1799         w->data.unit = NULL;
1800 }
1801
1802 bool unit_job_is_applicable(Unit *u, JobType j) {
1803         assert(u);
1804         assert(j >= 0 && j < _JOB_TYPE_MAX);
1805
1806         switch (j) {
1807
1808         case JOB_VERIFY_ACTIVE:
1809         case JOB_START:
1810         case JOB_STOP:
1811         case JOB_NOP:
1812                 return true;
1813
1814         case JOB_RESTART:
1815         case JOB_TRY_RESTART:
1816                 return unit_can_start(u);
1817
1818         case JOB_RELOAD:
1819                 return unit_can_reload(u);
1820
1821         case JOB_RELOAD_OR_START:
1822                 return unit_can_reload(u) && unit_can_start(u);
1823
1824         default:
1825                 assert_not_reached("Invalid job type");
1826         }
1827 }
1828
1829 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1830
1831         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1832                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1833                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1834                 [UNIT_WANTS] = UNIT_WANTED_BY,
1835                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1836                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1837                 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1838                 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1839                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1840                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1841                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1842                 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1843                 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1844                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1845                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1846                 [UNIT_BEFORE] = UNIT_AFTER,
1847                 [UNIT_AFTER] = UNIT_BEFORE,
1848                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1849                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1850                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1851                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1852                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1853                 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1854                 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1855         };
1856         int r, q = 0, v = 0, w = 0;
1857
1858         assert(u);
1859         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1860         assert(other);
1861
1862         u = unit_follow_merge(u);
1863         other = unit_follow_merge(other);
1864
1865         /* We won't allow dependencies on ourselves. We will not
1866          * consider them an error however. */
1867         if (u == other)
1868                 return 0;
1869
1870         if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1871                 return r;
1872
1873         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1874                 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1875                         return r;
1876
1877         if (add_reference)
1878                 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1879                     (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1880                         return r;
1881
1882         if ((q = set_put(u->dependencies[d], other)) < 0)
1883                 return q;
1884
1885         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1886                 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1887                         r = v;
1888                         goto fail;
1889                 }
1890
1891         if (add_reference) {
1892                 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1893                         r = w;
1894                         goto fail;
1895                 }
1896
1897                 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1898                         goto fail;
1899         }
1900
1901         unit_add_to_dbus_queue(u);
1902         return 0;
1903
1904 fail:
1905         if (q > 0)
1906                 set_remove(u->dependencies[d], other);
1907
1908         if (v > 0)
1909                 set_remove(other->dependencies[inverse_table[d]], u);
1910
1911         if (w > 0)
1912                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1913
1914         return r;
1915 }
1916
1917 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1918         int r;
1919
1920         assert(u);
1921
1922         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1923                 return r;
1924
1925         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1926                 return r;
1927
1928         return 0;
1929 }
1930
1931 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1932         char *s;
1933
1934         assert(u);
1935         assert(name || path);
1936         assert(p);
1937
1938         if (!name)
1939                 name = path_get_file_name(path);
1940
1941         if (!unit_name_is_template(name)) {
1942                 *p = NULL;
1943                 return name;
1944         }
1945
1946         if (u->instance)
1947                 s = unit_name_replace_instance(name, u->instance);
1948         else {
1949                 _cleanup_free_ char *i = NULL;
1950
1951                 i = unit_name_to_prefix(u->id);
1952                 if (!i)
1953                         return NULL;
1954
1955                 s = unit_name_replace_instance(name, i);
1956         }
1957
1958         if (!s)
1959                 return NULL;
1960
1961         *p = s;
1962         return s;
1963 }
1964
1965 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1966         Unit *other;
1967         int r;
1968         _cleanup_free_ char *s = NULL;
1969
1970         assert(u);
1971         assert(name || path);
1972
1973         name = resolve_template(u, name, path, &s);
1974         if (!name)
1975                 return -ENOMEM;
1976
1977         r = manager_load_unit(u->manager, name, path, NULL, &other);
1978         if (r < 0)
1979                 return r;
1980
1981         return unit_add_dependency(u, d, other, add_reference);
1982 }
1983
1984 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1985         Unit *other;
1986         int r;
1987         _cleanup_free_ char *s = NULL;
1988
1989         assert(u);
1990         assert(name || path);
1991
1992         if (!(name = resolve_template(u, name, path, &s)))
1993                 return -ENOMEM;
1994
1995         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1996                 return r;
1997
1998         r = unit_add_two_dependencies(u, d, e, other, add_reference);
1999
2000         return r;
2001 }
2002
2003 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2004         Unit *other;
2005         int r;
2006         _cleanup_free_ char *s = NULL;
2007
2008         assert(u);
2009         assert(name || path);
2010
2011         if (!(name = resolve_template(u, name, path, &s)))
2012                 return -ENOMEM;
2013
2014         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2015                 return r;
2016
2017         r = unit_add_dependency(other, d, u, add_reference);
2018
2019         return r;
2020 }
2021
2022 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2023         Unit *other;
2024         int r;
2025         _cleanup_free_ char *s = NULL;
2026
2027         assert(u);
2028         assert(name || path);
2029
2030         if (!(name = resolve_template(u, name, path, &s)))
2031                 return -ENOMEM;
2032
2033         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
2034                 return r;
2035
2036         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
2037                 return r;
2038
2039         return r;
2040 }
2041
2042 int set_unit_path(const char *p) {
2043         _cleanup_free_ char *c = NULL;
2044
2045         /* This is mostly for debug purposes */
2046         c = path_make_absolute_cwd(p);
2047         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
2048                 return -errno;
2049
2050         return 0;
2051 }
2052
2053 char *unit_dbus_path(Unit *u) {
2054         assert(u);
2055
2056         if (!u->id)
2057                 return NULL;
2058
2059         return unit_dbus_path_from_name(u->id);
2060 }
2061
2062 char *unit_default_cgroup_path(Unit *u) {
2063         _cleanup_free_ char *escaped = NULL, *slice = NULL;
2064         int r;
2065
2066         assert(u);
2067
2068         if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2069                 return strdup(u->manager->cgroup_root);
2070
2071         if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2072                 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2073                 if (r < 0)
2074                         return NULL;
2075         }
2076
2077         escaped = cg_escape(u->id);
2078         if (!escaped)
2079                 return NULL;
2080
2081         if (slice)
2082                 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2083         else
2084                 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2085 }
2086
2087 int unit_add_default_slice(Unit *u) {
2088         _cleanup_free_ char *b = NULL;
2089         const char *slice_name;
2090         Unit *slice;
2091         int r;
2092
2093         assert(u);
2094
2095         if (UNIT_ISSET(u->slice))
2096                 return 0;
2097
2098         if (!unit_get_cgroup_context(u))
2099                 return 0;
2100
2101         if (u->instance) {
2102                 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2103
2104                 /* Implicitly place all instantiated units in their
2105                  * own per-template slice */
2106
2107                 prefix = unit_name_to_prefix(u->id);
2108                 if (!prefix)
2109                         return -ENOMEM;
2110
2111                 /* The prefix is already escaped, but it might include
2112                  * "-" which has a special meaning for slice units,
2113                  * hence escape it here extra. */
2114                 escaped = strreplace(prefix, "-", "\\x2d");
2115                 if (!escaped)
2116                         return -ENOMEM;
2117
2118                 if (u->manager->running_as == SYSTEMD_SYSTEM)
2119                         b = strjoin("system-", escaped, ".slice", NULL);
2120                 else
2121                         b = strappend(escaped, ".slice");
2122                 if (!b)
2123                         return -ENOMEM;
2124
2125                 slice_name = b;
2126         } else
2127                 slice_name =
2128                         u->manager->running_as == SYSTEMD_SYSTEM
2129                         ? SPECIAL_SYSTEM_SLICE
2130                         : SPECIAL_ROOT_SLICE;
2131
2132         r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2133         if (r < 0)
2134                 return r;
2135
2136         unit_ref_set(&u->slice, slice);
2137         return 0;
2138 }
2139
2140 const char *unit_slice_name(Unit *u) {
2141         assert(u);
2142
2143         if (!UNIT_ISSET(u->slice))
2144                 return NULL;
2145
2146         return UNIT_DEREF(u->slice)->id;
2147 }
2148
2149 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2150         _cleanup_free_ char *t = NULL;
2151         int r;
2152
2153         assert(u);
2154         assert(type);
2155         assert(_found);
2156
2157         t = unit_name_change_suffix(u->id, type);
2158         if (!t)
2159                 return -ENOMEM;
2160
2161         assert(!unit_has_name(u, t));
2162
2163         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2164         assert(r < 0 || *_found != u);
2165         return r;
2166 }
2167
2168 int unit_watch_bus_name(Unit *u, const char *name) {
2169         assert(u);
2170         assert(name);
2171
2172         /* Watch a specific name on the bus. We only support one unit
2173          * watching each name for now. */
2174
2175         return hashmap_put(u->manager->watch_bus, name, u);
2176 }
2177
2178 void unit_unwatch_bus_name(Unit *u, const char *name) {
2179         assert(u);
2180         assert(name);
2181
2182         hashmap_remove_value(u->manager->watch_bus, name, u);
2183 }
2184
2185 bool unit_can_serialize(Unit *u) {
2186         assert(u);
2187
2188         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2189 }
2190
2191 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2192         int r;
2193
2194         assert(u);
2195         assert(f);
2196         assert(fds);
2197
2198         if (!unit_can_serialize(u))
2199                 return 0;
2200
2201         r = UNIT_VTABLE(u)->serialize(u, f, fds);
2202         if (r < 0)
2203                 return r;
2204
2205
2206         if (serialize_jobs) {
2207                 if (u->job) {
2208                         fprintf(f, "job\n");
2209                         job_serialize(u->job, f, fds);
2210                 }
2211
2212                 if (u->nop_job) {
2213                         fprintf(f, "job\n");
2214                         job_serialize(u->nop_job, f, fds);
2215                 }
2216         }
2217
2218         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2219         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2220         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2221         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2222         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2223
2224         if (dual_timestamp_is_set(&u->condition_timestamp))
2225                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2226
2227         unit_serialize_item(u, f, "transient", yes_no(u->transient));
2228
2229         if (u->cgroup_path)
2230                 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2231
2232         /* End marker */
2233         fputc('\n', f);
2234         return 0;
2235 }
2236
2237 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2238         va_list ap;
2239
2240         assert(u);
2241         assert(f);
2242         assert(key);
2243         assert(format);
2244
2245         fputs(key, f);
2246         fputc('=', f);
2247
2248         va_start(ap, format);
2249         vfprintf(f, format, ap);
2250         va_end(ap);
2251
2252         fputc('\n', f);
2253 }
2254
2255 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2256         assert(u);
2257         assert(f);
2258         assert(key);
2259         assert(value);
2260
2261         fprintf(f, "%s=%s\n", key, value);
2262 }
2263
2264 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2265         int r;
2266
2267         assert(u);
2268         assert(f);
2269         assert(fds);
2270
2271         if (!unit_can_serialize(u))
2272                 return 0;
2273
2274         for (;;) {
2275                 char line[LINE_MAX], *l, *v;
2276                 size_t k;
2277
2278                 if (!fgets(line, sizeof(line), f)) {
2279                         if (feof(f))
2280                                 return 0;
2281                         return -errno;
2282                 }
2283
2284                 char_array_0(line);
2285                 l = strstrip(line);
2286
2287                 /* End marker */
2288                 if (l[0] == 0)
2289                         return 0;
2290
2291                 k = strcspn(l, "=");
2292
2293                 if (l[k] == '=') {
2294                         l[k] = 0;
2295                         v = l+k+1;
2296                 } else
2297                         v = l+k;
2298
2299                 if (streq(l, "job")) {
2300                         if (v[0] == '\0') {
2301                                 /* new-style serialized job */
2302                                 Job *j = job_new_raw(u);
2303                                 if (!j)
2304                                         return -ENOMEM;
2305
2306                                 r = job_deserialize(j, f, fds);
2307                                 if (r < 0) {
2308                                         job_free(j);
2309                                         return r;
2310                                 }
2311
2312                                 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2313                                 if (r < 0) {
2314                                         job_free(j);
2315                                         return r;
2316                                 }
2317
2318                                 r = job_install_deserialized(j);
2319                                 if (r < 0) {
2320                                         hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2321                                         job_free(j);
2322                                         return r;
2323                                 }
2324
2325                                 if (j->state == JOB_RUNNING)
2326                                         u->manager->n_running_jobs++;
2327                         } else {
2328                                 /* legacy */
2329                                 JobType type = job_type_from_string(v);
2330                                 if (type < 0)
2331                                         log_debug("Failed to parse job type value %s", v);
2332                                 else
2333                                         u->deserialized_job = type;
2334                         }
2335                         continue;
2336                 } else if (streq(l, "inactive-exit-timestamp")) {
2337                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2338                         continue;
2339                 } else if (streq(l, "active-enter-timestamp")) {
2340                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2341                         continue;
2342                 } else if (streq(l, "active-exit-timestamp")) {
2343                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2344                         continue;
2345                 } else if (streq(l, "inactive-enter-timestamp")) {
2346                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2347                         continue;
2348                 } else if (streq(l, "condition-timestamp")) {
2349                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2350                         continue;
2351                 } else if (streq(l, "condition-result")) {
2352                         int b;
2353
2354                         b = parse_boolean(v);
2355                         if (b < 0)
2356                                 log_debug("Failed to parse condition result value %s", v);
2357                         else
2358                                 u->condition_result = b;
2359
2360                         continue;
2361
2362                 } else if (streq(l, "transient")) {
2363                         int b;
2364
2365                         b = parse_boolean(v);
2366                         if (b < 0)
2367                                 log_debug("Failed to parse transient bool %s", v);
2368                         else
2369                                 u->transient = b;
2370
2371                         continue;
2372                 } else if (streq(l, "cgroup")) {
2373                         char *s;
2374
2375                         s = strdup(v);
2376                         if (!s)
2377                                 return -ENOMEM;
2378
2379                         free(u->cgroup_path);
2380                         u->cgroup_path = s;
2381
2382                         assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2383                         continue;
2384                 }
2385
2386                 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2387                 if (r < 0)
2388                         return r;
2389         }
2390 }
2391
2392 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2393         Unit *device;
2394         _cleanup_free_ char *e = NULL;
2395         int r;
2396
2397         assert(u);
2398
2399         if (!what)
2400                 return 0;
2401
2402         /* Adds in links to the device node that this unit is based on */
2403
2404         if (!is_device_path(what))
2405                 return 0;
2406
2407         e = unit_name_from_path(what, ".device");
2408         if (!e)
2409                 return -ENOMEM;
2410
2411         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2412
2413         if (r < 0)
2414                 return r;
2415
2416         r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2417         if (r < 0)
2418                 return r;
2419
2420         if (wants) {
2421                 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2422                 if (r < 0)
2423                         return r;
2424         }
2425
2426         return 0;
2427 }
2428
2429 int unit_coldplug(Unit *u) {
2430         int r;
2431
2432         assert(u);
2433
2434         if (UNIT_VTABLE(u)->coldplug)
2435                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2436                         return r;
2437
2438         if (u->job) {
2439                 r = job_coldplug(u->job);
2440                 if (r < 0)
2441                         return r;
2442         } else if (u->deserialized_job >= 0) {
2443                 /* legacy */
2444                 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2445                 if (r < 0)
2446                         return r;
2447
2448                 u->deserialized_job = _JOB_TYPE_INVALID;
2449         }
2450
2451         return 0;
2452 }
2453
2454 #pragma GCC diagnostic push
2455 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
2456 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2457         manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2458 }
2459 #pragma GCC diagnostic pop
2460
2461 bool unit_need_daemon_reload(Unit *u) {
2462         _cleanup_strv_free_ char **t = NULL;
2463         char **path;
2464         struct stat st;
2465         unsigned loaded_cnt, current_cnt;
2466
2467         assert(u);
2468
2469         if (u->fragment_path) {
2470                 zero(st);
2471                 if (stat(u->fragment_path, &st) < 0)
2472                         /* What, cannot access this anymore? */
2473                         return true;
2474
2475                 if (u->fragment_mtime > 0 &&
2476                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2477                         return true;
2478         }
2479
2480         if (u->source_path) {
2481                 zero(st);
2482                 if (stat(u->source_path, &st) < 0)
2483                         return true;
2484
2485                 if (u->source_mtime > 0 &&
2486                     timespec_load(&st.st_mtim) != u->source_mtime)
2487                         return true;
2488         }
2489
2490         t = unit_find_dropin_paths(u);
2491         loaded_cnt = strv_length(t);
2492         current_cnt = strv_length(u->dropin_paths);
2493
2494         if (loaded_cnt == current_cnt) {
2495                 if (loaded_cnt == 0)
2496                         return false;
2497
2498                 if (strv_overlap(u->dropin_paths, t)) {
2499                         STRV_FOREACH(path, u->dropin_paths) {
2500                                 zero(st);
2501                                 if (stat(*path, &st) < 0)
2502                                         return true;
2503
2504                                 if (u->dropin_mtime > 0 &&
2505                                     timespec_load(&st.st_mtim) > u->dropin_mtime)
2506                                         return true;
2507                         }
2508
2509                         return false;
2510                 } else
2511                         return true;
2512         } else
2513                 return true;
2514 }
2515
2516 void unit_reset_failed(Unit *u) {
2517         assert(u);
2518
2519         if (UNIT_VTABLE(u)->reset_failed)
2520                 UNIT_VTABLE(u)->reset_failed(u);
2521 }
2522
2523 Unit *unit_following(Unit *u) {
2524         assert(u);
2525
2526         if (UNIT_VTABLE(u)->following)
2527                 return UNIT_VTABLE(u)->following(u);
2528
2529         return NULL;
2530 }
2531
2532 bool unit_stop_pending(Unit *u) {
2533         assert(u);
2534
2535         /* This call does check the current state of the unit. It's
2536          * hence useful to be called from state change calls of the
2537          * unit itself, where the state isn't updated yet. This is
2538          * different from unit_inactive_or_pending() which checks both
2539          * the current state and for a queued job. */
2540
2541         return u->job && u->job->type == JOB_STOP;
2542 }
2543
2544 bool unit_inactive_or_pending(Unit *u) {
2545         assert(u);
2546
2547         /* Returns true if the unit is inactive or going down */
2548
2549         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2550                 return true;
2551
2552         if (unit_stop_pending(u))
2553                 return true;
2554
2555         return false;
2556 }
2557
2558 bool unit_active_or_pending(Unit *u) {
2559         assert(u);
2560
2561         /* Returns true if the unit is active or going up */
2562
2563         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2564                 return true;
2565
2566         if (u->job &&
2567             (u->job->type == JOB_START ||
2568              u->job->type == JOB_RELOAD_OR_START ||
2569              u->job->type == JOB_RESTART))
2570                 return true;
2571
2572         return false;
2573 }
2574
2575 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2576         assert(u);
2577         assert(w >= 0 && w < _KILL_WHO_MAX);
2578         assert(signo > 0);
2579         assert(signo < _NSIG);
2580
2581         if (!UNIT_VTABLE(u)->kill)
2582                 return -ENOTSUP;
2583
2584         return UNIT_VTABLE(u)->kill(u, w, signo, error);
2585 }
2586
2587 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2588         Set *pid_set;
2589         int r;
2590
2591         pid_set = set_new(trivial_hash_func, trivial_compare_func);
2592         if (!pid_set)
2593                 return NULL;
2594
2595         /* Exclude the main/control pids from being killed via the cgroup */
2596         if (main_pid > 0) {
2597                 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2598                 if (r < 0)
2599                         goto fail;
2600         }
2601
2602         if (control_pid > 0) {
2603                 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2604                 if (r < 0)
2605                         goto fail;
2606         }
2607
2608         return pid_set;
2609
2610 fail:
2611         set_free(pid_set);
2612         return NULL;
2613 }
2614
2615 int unit_kill_common(
2616                 Unit *u,
2617                 KillWho who,
2618                 int signo,
2619                 pid_t main_pid,
2620                 pid_t control_pid,
2621                 DBusError *error) {
2622
2623         int r = 0;
2624
2625         if (who == KILL_MAIN && main_pid <= 0) {
2626                 if (main_pid < 0)
2627                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2628                 else
2629                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2630                 return -ESRCH;
2631         }
2632
2633         if (who == KILL_CONTROL && control_pid <= 0) {
2634                 if (control_pid < 0)
2635                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2636                 else
2637                         dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2638                 return -ESRCH;
2639         }
2640
2641         if (who == KILL_CONTROL || who == KILL_ALL)
2642                 if (control_pid > 0)
2643                         if (kill(control_pid, signo) < 0)
2644                                 r = -errno;
2645
2646         if (who == KILL_MAIN || who == KILL_ALL)
2647                 if (main_pid > 0)
2648                         if (kill(main_pid, signo) < 0)
2649                                 r = -errno;
2650
2651         if (who == KILL_ALL && u->cgroup_path) {
2652                 _cleanup_set_free_ Set *pid_set = NULL;
2653                 int q;
2654
2655                 /* Exclude the main/control pids from being killed via the cgroup */
2656                 pid_set = unit_pid_set(main_pid, control_pid);
2657                 if (!pid_set)
2658                         return -ENOMEM;
2659
2660                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
2661                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2662                         r = q;
2663         }
2664
2665         return r;
2666 }
2667
2668 int unit_following_set(Unit *u, Set **s) {
2669         assert(u);
2670         assert(s);
2671
2672         if (UNIT_VTABLE(u)->following_set)
2673                 return UNIT_VTABLE(u)->following_set(u, s);
2674
2675         *s = NULL;
2676         return 0;
2677 }
2678
2679 UnitFileState unit_get_unit_file_state(Unit *u) {
2680         assert(u);
2681
2682         if (u->unit_file_state < 0 && u->fragment_path)
2683                 u->unit_file_state = unit_file_get_state(
2684                                 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2685                                 NULL, path_get_file_name(u->fragment_path));
2686
2687         return u->unit_file_state;
2688 }
2689
2690 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2691         assert(ref);
2692         assert(u);
2693
2694         if (ref->unit)
2695                 unit_ref_unset(ref);
2696
2697         ref->unit = u;
2698         LIST_PREPEND(refs, u->refs, ref);
2699         return u;
2700 }
2701
2702 void unit_ref_unset(UnitRef *ref) {
2703         assert(ref);
2704
2705         if (!ref->unit)
2706                 return;
2707
2708         LIST_REMOVE(refs, ref->unit->refs, ref);
2709         ref->unit = NULL;
2710 }
2711
2712 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2713         unsigned i;
2714         int r;
2715
2716         assert(u);
2717         assert(c);
2718
2719         /* This only copies in the ones that need memory */
2720         for (i = 0; i < RLIMIT_NLIMITS; i++)
2721                 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2722                         c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2723                         if (!c->rlimit[i])
2724                                 return -ENOMEM;
2725                 }
2726
2727         if (u->manager->running_as == SYSTEMD_USER &&
2728             !c->working_directory) {
2729
2730                 r = get_home_dir(&c->working_directory);
2731                 if (r < 0)
2732                         return r;
2733         }
2734
2735         return 0;
2736 }
2737
2738 ExecContext *unit_get_exec_context(Unit *u) {
2739         size_t offset;
2740         assert(u);
2741
2742         offset = UNIT_VTABLE(u)->exec_context_offset;
2743         if (offset <= 0)
2744                 return NULL;
2745
2746         return (ExecContext*) ((uint8_t*) u + offset);
2747 }
2748
2749 CGroupContext *unit_get_cgroup_context(Unit *u) {
2750         size_t offset;
2751
2752         offset = UNIT_VTABLE(u)->cgroup_context_offset;
2753         if (offset <= 0)
2754                 return NULL;
2755
2756         return (CGroupContext*) ((uint8_t*) u + offset);
2757 }
2758
2759 static int drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **_p, char **_q) {
2760         _cleanup_free_ char *b = NULL;
2761         char *p, *q;
2762         int r;
2763
2764         assert(u);
2765         assert(name);
2766         assert(_p);
2767         assert(_q);
2768         assert(mode & (UNIT_PERSISTENT|UNIT_RUNTIME));
2769
2770         b = xescape(name, "/.");
2771         if (!b)
2772                 return -ENOMEM;
2773
2774         if (!filename_is_safe(b))
2775                 return -EINVAL;
2776
2777         if (u->manager->running_as == SYSTEMD_USER) {
2778                 _cleanup_free_ char *c = NULL;
2779
2780                 r = user_config_home(&c);
2781                 if (r < 0)
2782                         return r;
2783                 if (r == 0)
2784                         return -ENOENT;
2785
2786                 p = strjoin(c, "/", u->id, ".d", NULL);
2787         } else if (mode & UNIT_PERSISTENT)
2788                 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2789         else
2790                 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2791         if (!p)
2792                 return -ENOMEM;
2793
2794         q = strjoin(p, "/90-", b, ".conf", NULL);
2795         if (!q) {
2796                 free(p);
2797                 return -ENOMEM;
2798         }
2799
2800         *_p = p;
2801         *_q = q;
2802         return 0;
2803 }
2804
2805 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2806         _cleanup_free_ char *p = NULL, *q = NULL;
2807         int r;
2808
2809         assert(u);
2810         assert(name);
2811         assert(data);
2812
2813         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2814                 return 0;
2815
2816         r = drop_in_file(u, mode, name, &p, &q);
2817         if (r < 0)
2818                 return r;
2819
2820         mkdir_p(p, 0755);
2821         return write_string_file_atomic_label(q, data);
2822 }
2823
2824 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2825         _cleanup_free_ char *p = NULL;
2826         va_list ap;
2827         int r;
2828
2829         assert(u);
2830         assert(name);
2831         assert(format);
2832
2833         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2834                 return 0;
2835
2836         va_start(ap, format);
2837         r = vasprintf(&p, format, ap);
2838         va_end(ap);
2839
2840         if (r < 0)
2841                 return -ENOMEM;
2842
2843         return unit_write_drop_in(u, mode, name, p);
2844 }
2845
2846 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
2847         _cleanup_free_ char *ndata = NULL;
2848
2849         assert(u);
2850         assert(name);
2851         assert(data);
2852
2853         if (!UNIT_VTABLE(u)->private_section)
2854                 return -EINVAL;
2855
2856         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2857                 return 0;
2858
2859         ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
2860         if (!ndata)
2861                 return -ENOMEM;
2862
2863         return unit_write_drop_in(u, mode, name, ndata);
2864 }
2865
2866 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
2867         _cleanup_free_ char *p = NULL;
2868         va_list ap;
2869         int r;
2870
2871         assert(u);
2872         assert(name);
2873         assert(format);
2874
2875         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2876                 return 0;
2877
2878         va_start(ap, format);
2879         r = vasprintf(&p, format, ap);
2880         va_end(ap);
2881
2882         if (r < 0)
2883                 return -ENOMEM;
2884
2885         return unit_write_drop_in_private(u, mode, name, p);
2886 }
2887
2888 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
2889         _cleanup_free_ char *p = NULL, *q = NULL;
2890         int r;
2891
2892         assert(u);
2893
2894         if (!(mode & (UNIT_PERSISTENT|UNIT_RUNTIME)))
2895                 return 0;
2896
2897         r = drop_in_file(u, mode, name, &p, &q);
2898         if (r < 0)
2899                 return r;
2900
2901         if (unlink(q) < 0)
2902                 r = errno == ENOENT ? 0 : -errno;
2903         else
2904                 r = 1;
2905
2906         rmdir(p);
2907         return r;
2908 }
2909
2910 int unit_make_transient(Unit *u) {
2911         int r;
2912
2913         assert(u);
2914
2915         u->load_state = UNIT_STUB;
2916         u->load_error = 0;
2917         u->transient = true;
2918
2919         free(u->fragment_path);
2920         u->fragment_path = NULL;
2921
2922         if (u->manager->running_as == SYSTEMD_USER) {
2923                 _cleanup_free_ char *c = NULL;
2924
2925                 r = user_config_home(&c);
2926                 if (r < 0)
2927                         return r;
2928                 if (r == 0)
2929                         return -ENOENT;
2930
2931                 u->fragment_path = strjoin(c, "/", u->id, NULL);
2932                 if (!u->fragment_path)
2933                         return -ENOMEM;
2934
2935                 mkdir_p(c, 0755);
2936         } else {
2937                 u->fragment_path = strappend("/run/systemd/system/", u->id);
2938                 if (!u->fragment_path)
2939                         return -ENOMEM;
2940
2941                 mkdir_p("/run/systemd/system", 0755);
2942         }
2943
2944         return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
2945 }
2946
2947 int unit_kill_context(
2948                 Unit *u,
2949                 KillContext *c,
2950                 bool sigkill,
2951                 pid_t main_pid,
2952                 pid_t control_pid,
2953                 bool main_pid_alien) {
2954
2955         int sig, wait_for_exit = 0, r;
2956
2957         assert(u);
2958         assert(c);
2959
2960         if (c->kill_mode == KILL_NONE)
2961                 return 0;
2962
2963         sig = sigkill ? SIGKILL : c->kill_signal;
2964
2965         if (main_pid > 0) {
2966                 r = kill_and_sigcont(main_pid, sig);
2967
2968                 if (r < 0 && r != -ESRCH) {
2969                         _cleanup_free_ char *comm = NULL;
2970                         get_process_comm(main_pid, &comm);
2971
2972                         log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2973                                          (long) main_pid, strna(comm), strerror(-r));
2974                 } else {
2975                         wait_for_exit = !main_pid_alien;
2976
2977                         if (c->send_sighup)
2978                                 kill(main_pid, SIGHUP);
2979                 }
2980         }
2981
2982         if (control_pid > 0) {
2983                 r = kill_and_sigcont(control_pid, sig);
2984
2985                 if (r < 0 && r != -ESRCH) {
2986                         _cleanup_free_ char *comm = NULL;
2987                         get_process_comm(control_pid, &comm);
2988
2989                         log_warning_unit(u->id,
2990                                          "Failed to kill control process %li (%s): %s",
2991                                          (long) control_pid, strna(comm), strerror(-r));
2992                 } else {
2993                         wait_for_exit = true;
2994
2995                         if (c->send_sighup)
2996                                 kill(control_pid, SIGHUP);
2997                 }
2998         }
2999
3000         if (c->kill_mode == KILL_CONTROL_GROUP && u->cgroup_path) {
3001                 _cleanup_set_free_ Set *pid_set = NULL;
3002
3003                 /* Exclude the main/control pids from being killed via the cgroup */
3004                 pid_set = unit_pid_set(main_pid, control_pid);
3005                 if (!pid_set)
3006                         return -ENOMEM;
3007
3008                 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3009                 if (r < 0) {
3010                         if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3011                                 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3012                 } else if (r > 0) {
3013                         wait_for_exit = true;
3014                         if (c->send_sighup) {
3015                                 set_free(pid_set);
3016
3017                                 pid_set = unit_pid_set(main_pid, control_pid);
3018                                 if (!pid_set)
3019                                         return -ENOMEM;
3020
3021                                 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, true, true, false, pid_set);
3022                         }
3023                 }
3024         }
3025
3026         return wait_for_exit;
3027 }
3028
3029 int unit_require_mounts_for(Unit *u, const char *path) {
3030         char prefix[strlen(path) + 1], *p;
3031         int r;
3032
3033         assert(u);
3034         assert(path);
3035
3036         /* Registers a unit for requiring a certain path and all its
3037          * prefixes. We keep a simple array of these paths in the
3038          * unit, since its usually short. However, we build a prefix
3039          * table for all possible prefixes so that new appearing mount
3040          * units can easily determine which units to make themselves a
3041          * dependency of. */
3042
3043         p = strdup(path);
3044         if (!p)
3045                 return -ENOMEM;
3046
3047         path_kill_slashes(p);
3048
3049         if (!path_is_absolute(p)) {
3050                 free(p);
3051                 return -EINVAL;
3052         }
3053
3054         if (!path_is_safe(p)) {
3055                 free(p);
3056                 return -EPERM;
3057         }
3058
3059         if (strv_contains(u->requires_mounts_for, p)) {
3060                 free(p);
3061                 return 0;
3062         }
3063
3064         r = strv_push(&u->requires_mounts_for, p);
3065         if (r < 0) {
3066                 free(p);
3067                 return r;
3068         }
3069
3070         PATH_FOREACH_PREFIX_MORE(prefix, p) {
3071                 Set *x;
3072
3073                 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3074                 if (!x) {
3075                         char *q;
3076
3077                         if (!u->manager->units_requiring_mounts_for) {
3078                                 u->manager->units_requiring_mounts_for = hashmap_new(string_hash_func, string_compare_func);
3079                                 if (!u->manager->units_requiring_mounts_for)
3080                                         return -ENOMEM;
3081                         }
3082
3083                         q = strdup(prefix);
3084                         if (!q)
3085                                 return -ENOMEM;
3086
3087                         x = set_new(NULL, NULL);
3088                         if (!x) {
3089                                 free(q);
3090                                 return -ENOMEM;
3091                         }
3092
3093                         r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3094                         if (r < 0) {
3095                                 free(q);
3096                                 set_free(x);
3097                                 return r;
3098                         }
3099                 }
3100
3101                 r = set_put(x, u);
3102                 if (r < 0)
3103                         return r;
3104         }
3105
3106         return 0;
3107 }
3108
3109 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3110         [UNIT_ACTIVE] = "active",
3111         [UNIT_RELOADING] = "reloading",
3112         [UNIT_INACTIVE] = "inactive",
3113         [UNIT_FAILED] = "failed",
3114         [UNIT_ACTIVATING] = "activating",
3115         [UNIT_DEACTIVATING] = "deactivating"
3116 };
3117
3118 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3119
3120 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3121         [UNIT_REQUIRES] = "Requires",
3122         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3123         [UNIT_REQUISITE] = "Requisite",
3124         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3125         [UNIT_WANTS] = "Wants",
3126         [UNIT_BINDS_TO] = "BindsTo",
3127         [UNIT_PART_OF] = "PartOf",
3128         [UNIT_REQUIRED_BY] = "RequiredBy",
3129         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3130         [UNIT_WANTED_BY] = "WantedBy",
3131         [UNIT_BOUND_BY] = "BoundBy",
3132         [UNIT_CONSISTS_OF] = "ConsistsOf",
3133         [UNIT_CONFLICTS] = "Conflicts",
3134         [UNIT_CONFLICTED_BY] = "ConflictedBy",
3135         [UNIT_BEFORE] = "Before",
3136         [UNIT_AFTER] = "After",
3137         [UNIT_ON_FAILURE] = "OnFailure",
3138         [UNIT_TRIGGERS] = "Triggers",
3139         [UNIT_TRIGGERED_BY] = "TriggeredBy",
3140         [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3141         [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3142         [UNIT_REFERENCES] = "References",
3143         [UNIT_REFERENCED_BY] = "ReferencedBy",
3144 };
3145
3146 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);