src/core/unit.c

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