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