src/core/unit.c

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