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