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