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