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