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