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 "set.h"
  33 #include "unit.h"
  34 #include "macro.h"
  35 #include "strv.h"
  36 #include "load-fragment.h"
  37 #include "load-dropin.h"
  38 #include "log.h"
  39 #include "unit-name.h"
  40 #include "specifier.h"
  41 #include "dbus-unit.h"
  42 #include "special.h"
  43 #include "cgroup-util.h"
  44 #include "missing.h"
  45 #include "cgroup-attr.h"
  46
  47 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
  48         [UNIT_SERVICE] = &service_vtable,
  49         [UNIT_TIMER] = &timer_vtable,
  50         [UNIT_SOCKET] = &socket_vtable,
  51         [UNIT_TARGET] = &target_vtable,
  52         [UNIT_DEVICE] = &device_vtable,
  53         [UNIT_MOUNT] = &mount_vtable,
  54         [UNIT_AUTOMOUNT] = &automount_vtable,
  55         [UNIT_SNAPSHOT] = &snapshot_vtable,
  56         [UNIT_SWAP] = &swap_vtable,
  57         [UNIT_PATH] = &path_vtable
  58 };
  59
  60 Unit *unit_new(Manager *m, size_t size) {
  61         Unit *u;
  62
  63         assert(m);
  64         assert(size >= sizeof(Unit));
  65
  66         u = malloc0(size);
  67         if (!u)
  68                 return NULL;
  69
  70         u->names = set_new(string_hash_func, string_compare_func);
  71         if (!u->names) {
  72                 free(u);
  73                 return NULL;
  74         }
  75
  76         u->manager = m;
  77         u->type = _UNIT_TYPE_INVALID;
  78         u->deserialized_job = _JOB_TYPE_INVALID;
  79         u->default_dependencies = true;
  80         u->unit_file_state = _UNIT_FILE_STATE_INVALID;
  81
  82         return u;
  83 }
  84
  85 bool unit_has_name(Unit *u, const char *name) {
  86         assert(u);
  87         assert(name);
  88
  89         return !!set_get(u->names, (char*) name);
  90 }
  91
  92 int unit_add_name(Unit *u, const char *text) {
  93         UnitType t;
  94         char *s, *i = NULL;
  95         int r;
  96
  97         assert(u);
  98         assert(text);
  99
 100         if (unit_name_is_template(text)) {
 101                 if (!u->instance)
 102                         return -EINVAL;
 103
 104                 s = unit_name_replace_instance(text, u->instance);
 105         } else
 106                 s = strdup(text);
 107
 108         if (!s)
 109                 return -ENOMEM;
 110
 111         if (!unit_name_is_valid(s, false)) {
 112                 r = -EINVAL;
 113                 goto fail;
 114         }
 115
 116         assert_se((t = unit_name_to_type(s)) >= 0);
 117
 118         if (u->type != _UNIT_TYPE_INVALID && t != u->type) {
 119                 r = -EINVAL;
 120                 goto fail;
 121         }
 122
 123         if ((r = unit_name_to_instance(s, &i)) < 0)
 124                 goto fail;
 125
 126         if (i && unit_vtable[t]->no_instances) {
 127                 r = -EINVAL;
 128                 goto fail;
 129         }
 130
 131         /* Ensure that this unit is either instanced or not instanced,
 132          * but not both. */
 133         if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i) {
 134                 r = -EINVAL;
 135                 goto fail;
 136         }
 137
 138         if (unit_vtable[t]->no_alias &&
 139             !set_isempty(u->names) &&
 140             !set_get(u->names, s)) {
 141                 r = -EEXIST;
 142                 goto fail;
 143         }
 144
 145         if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES) {
 146                 r = -E2BIG;
 147                 goto fail;
 148         }
 149
 150         if ((r = set_put(u->names, s)) < 0) {
 151                 if (r == -EEXIST)
 152                         r = 0;
 153                 goto fail;
 154         }
 155
 156         if ((r = hashmap_put(u->manager->units, s, u)) < 0) {
 157                 set_remove(u->names, s);
 158                 goto fail;
 159         }
 160
 161         if (u->type == _UNIT_TYPE_INVALID) {
 162
 163                 u->type = t;
 164                 u->id = s;
 165                 u->instance = i;
 166
 167                 LIST_PREPEND(Unit, units_by_type, u->manager->units_by_type[t], u);
 168
 169                 if (UNIT_VTABLE(u)->init)
 170                         UNIT_VTABLE(u)->init(u);
 171         } else
 172                 free(i);
 173
 174         unit_add_to_dbus_queue(u);
 175         return 0;
 176
 177 fail:
 178         free(s);
 179         free(i);
 180
 181         return r;
 182 }
 183
 184 int unit_choose_id(Unit *u, const char *name) {
 185         char *s, *t = NULL, *i;
 186         int r;
 187
 188         assert(u);
 189         assert(name);
 190
 191         if (unit_name_is_template(name)) {
 192
 193                 if (!u->instance)
 194                         return -EINVAL;
 195
 196                 if (!(t = unit_name_replace_instance(name, u->instance)))
 197                         return -ENOMEM;
 198
 199                 name = t;
 200         }
 201
 202         /* Selects one of the names of this unit as the id */
 203         s = set_get(u->names, (char*) name);
 204         free(t);
 205
 206         if (!s)
 207                 return -ENOENT;
 208
 209         if ((r = unit_name_to_instance(s, &i)) < 0)
 210                 return r;
 211
 212         u->id = s;
 213
 214         free(u->instance);
 215         u->instance = i;
 216
 217         unit_add_to_dbus_queue(u);
 218
 219         return 0;
 220 }
 221
 222 int unit_set_description(Unit *u, const char *description) {
 223         char *s;
 224
 225         assert(u);
 226
 227         if (!(s = strdup(description)))
 228                 return -ENOMEM;
 229
 230         free(u->description);
 231         u->description = s;
 232
 233         unit_add_to_dbus_queue(u);
 234         return 0;
 235 }
 236
 237 bool unit_check_gc(Unit *u) {
 238         assert(u);
 239
 240         if (u->load_state == UNIT_STUB)
 241                 return true;
 242
 243         if (UNIT_VTABLE(u)->no_gc)
 244                 return true;
 245
 246         if (u->no_gc)
 247                 return true;
 248
 249         if (u->job)
 250                 return true;
 251
 252         if (unit_active_state(u) != UNIT_INACTIVE)
 253                 return true;
 254
 255         if (UNIT_VTABLE(u)->check_gc)
 256                 if (UNIT_VTABLE(u)->check_gc(u))
 257                         return true;
 258
 259         return false;
 260 }
 261
 262 void unit_add_to_load_queue(Unit *u) {
 263         assert(u);
 264         assert(u->type != _UNIT_TYPE_INVALID);
 265
 266         if (u->load_state != UNIT_STUB || u->in_load_queue)
 267                 return;
 268
 269         LIST_PREPEND(Unit, load_queue, u->manager->load_queue, u);
 270         u->in_load_queue = true;
 271 }
 272
 273 void unit_add_to_cleanup_queue(Unit *u) {
 274         assert(u);
 275
 276         if (u->in_cleanup_queue)
 277                 return;
 278
 279         LIST_PREPEND(Unit, cleanup_queue, u->manager->cleanup_queue, u);
 280         u->in_cleanup_queue = true;
 281 }
 282
 283 void unit_add_to_gc_queue(Unit *u) {
 284         assert(u);
 285
 286         if (u->in_gc_queue || u->in_cleanup_queue)
 287                 return;
 288
 289         if (unit_check_gc(u))
 290                 return;
 291
 292         LIST_PREPEND(Unit, gc_queue, u->manager->gc_queue, u);
 293         u->in_gc_queue = true;
 294
 295         u->manager->n_in_gc_queue ++;
 296
 297         if (u->manager->gc_queue_timestamp <= 0)
 298                 u->manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
 299 }
 300
 301 void unit_add_to_dbus_queue(Unit *u) {
 302         assert(u);
 303         assert(u->type != _UNIT_TYPE_INVALID);
 304
 305         if (u->load_state == UNIT_STUB || u->in_dbus_queue)
 306                 return;
 307
 308         /* Shortcut things if nobody cares */
 309         if (!bus_has_subscriber(u->manager)) {
 310                 u->sent_dbus_new_signal = true;
 311                 return;
 312         }
 313
 314         LIST_PREPEND(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
 315         u->in_dbus_queue = true;
 316 }
 317
 318 static void bidi_set_free(Unit *u, Set *s) {
 319         Iterator i;
 320         Unit *other;
 321
 322         assert(u);
 323
 324         /* Frees the set and makes sure we are dropped from the
 325          * inverse pointers */
 326
 327         SET_FOREACH(other, s, i) {
 328                 UnitDependency d;
 329
 330                 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 331                         set_remove(other->dependencies[d], u);
 332
 333                 unit_add_to_gc_queue(other);
 334         }
 335
 336         set_free(s);
 337 }
 338
 339 void unit_free(Unit *u) {
 340         UnitDependency d;
 341         Iterator i;
 342         char *t;
 343
 344         assert(u);
 345
 346         bus_unit_send_removed_signal(u);
 347
 348         if (u->load_state != UNIT_STUB)
 349                 if (UNIT_VTABLE(u)->done)
 350                         UNIT_VTABLE(u)->done(u);
 351
 352         SET_FOREACH(t, u->names, i)
 353                 hashmap_remove_value(u->manager->units, t, u);
 354
 355         if (u->job) {
 356                 Job *j = u->job;
 357                 job_uninstall(j);
 358                 job_free(j);
 359         }
 360
 361         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 362                 bidi_set_free(u, u->dependencies[d]);
 363
 364         if (u->type != _UNIT_TYPE_INVALID)
 365                 LIST_REMOVE(Unit, units_by_type, u->manager->units_by_type[u->type], u);
 366
 367         if (u->in_load_queue)
 368                 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
 369
 370         if (u->in_dbus_queue)
 371                 LIST_REMOVE(Unit, dbus_queue, u->manager->dbus_unit_queue, u);
 372
 373         if (u->in_cleanup_queue)
 374                 LIST_REMOVE(Unit, cleanup_queue, u->manager->cleanup_queue, u);
 375
 376         if (u->in_gc_queue) {
 377                 LIST_REMOVE(Unit, gc_queue, u->manager->gc_queue, u);
 378                 u->manager->n_in_gc_queue--;
 379         }
 380
 381         cgroup_bonding_free_list(u->cgroup_bondings, u->manager->n_reloading <= 0);
 382         cgroup_attribute_free_list(u->cgroup_attributes);
 383
 384         free(u->description);
 385         free(u->fragment_path);
 386         free(u->instance);
 387
 388         set_free_free(u->names);
 389
 390         condition_free_list(u->conditions);
 391
 392         while (u->refs)
 393                 unit_ref_unset(u->refs);
 394
 395         free(u);
 396 }
 397
 398 UnitActiveState unit_active_state(Unit *u) {
 399         assert(u);
 400
 401         if (u->load_state == UNIT_MERGED)
 402                 return unit_active_state(unit_follow_merge(u));
 403
 404         /* After a reload it might happen that a unit is not correctly
 405          * loaded but still has a process around. That's why we won't
 406          * shortcut failed loading to UNIT_INACTIVE_FAILED. */
 407
 408         return UNIT_VTABLE(u)->active_state(u);
 409 }
 410
 411 const char* unit_sub_state_to_string(Unit *u) {
 412         assert(u);
 413
 414         return UNIT_VTABLE(u)->sub_state_to_string(u);
 415 }
 416
 417 static void complete_move(Set **s, Set **other) {
 418         assert(s);
 419         assert(other);
 420
 421         if (!*other)
 422                 return;
 423
 424         if (*s)
 425                 set_move(*s, *other);
 426         else {
 427                 *s = *other;
 428                 *other = NULL;
 429         }
 430 }
 431
 432 static void merge_names(Unit *u, Unit *other) {
 433         char *t;
 434         Iterator i;
 435
 436         assert(u);
 437         assert(other);
 438
 439         complete_move(&u->names, &other->names);
 440
 441         set_free_free(other->names);
 442         other->names = NULL;
 443         other->id = NULL;
 444
 445         SET_FOREACH(t, u->names, i)
 446                 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
 447 }
 448
 449 static void merge_dependencies(Unit *u, Unit *other, UnitDependency d) {
 450         Iterator i;
 451         Unit *back;
 452         int r;
 453
 454         assert(u);
 455         assert(other);
 456         assert(d < _UNIT_DEPENDENCY_MAX);
 457
 458         /* Fix backwards pointers */
 459         SET_FOREACH(back, other->dependencies[d], i) {
 460                 UnitDependency k;
 461
 462                 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++)
 463                         if ((r = set_remove_and_put(back->dependencies[k], other, u)) < 0) {
 464
 465                                 if (r == -EEXIST)
 466                                         set_remove(back->dependencies[k], other);
 467                                 else
 468                                         assert(r == -ENOENT);
 469                         }
 470         }
 471
 472         complete_move(&u->dependencies[d], &other->dependencies[d]);
 473
 474         set_free(other->dependencies[d]);
 475         other->dependencies[d] = NULL;
 476 }
 477
 478 int unit_merge(Unit *u, Unit *other) {
 479         UnitDependency d;
 480
 481         assert(u);
 482         assert(other);
 483         assert(u->manager == other->manager);
 484         assert(u->type != _UNIT_TYPE_INVALID);
 485
 486         other = unit_follow_merge(other);
 487
 488         if (other == u)
 489                 return 0;
 490
 491         if (u->type != other->type)
 492                 return -EINVAL;
 493
 494         if (!u->instance != !other->instance)
 495                 return -EINVAL;
 496
 497         if (other->load_state != UNIT_STUB &&
 498             other->load_state != UNIT_ERROR)
 499                 return -EEXIST;
 500
 501         if (other->job)
 502                 return -EEXIST;
 503
 504         if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
 505                 return -EEXIST;
 506
 507         /* Merge names */
 508         merge_names(u, other);
 509
 510         /* Redirect all references */
 511         while (other->refs)
 512                 unit_ref_set(other->refs, u);
 513
 514         /* Merge dependencies */
 515         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
 516                 merge_dependencies(u, other, d);
 517
 518         other->load_state = UNIT_MERGED;
 519         other->merged_into = u;
 520
 521         /* If there is still some data attached to the other node, we
 522          * don't need it anymore, and can free it. */
 523         if (other->load_state != UNIT_STUB)
 524                 if (UNIT_VTABLE(other)->done)
 525                         UNIT_VTABLE(other)->done(other);
 526
 527         unit_add_to_dbus_queue(u);
 528         unit_add_to_cleanup_queue(other);
 529
 530         return 0;
 531 }
 532
 533 int unit_merge_by_name(Unit *u, const char *name) {
 534         Unit *other;
 535         int r;
 536         char *s = NULL;
 537
 538         assert(u);
 539         assert(name);
 540
 541         if (unit_name_is_template(name)) {
 542                 if (!u->instance)
 543                         return -EINVAL;
 544
 545                 if (!(s = unit_name_replace_instance(name, u->instance)))
 546                         return -ENOMEM;
 547
 548                 name = s;
 549         }
 550
 551         if (!(other = manager_get_unit(u->manager, name)))
 552                 r = unit_add_name(u, name);
 553         else
 554                 r = unit_merge(u, other);
 555
 556         free(s);
 557         return r;
 558 }
 559
 560 Unit* unit_follow_merge(Unit *u) {
 561         assert(u);
 562
 563         while (u->load_state == UNIT_MERGED)
 564                 assert_se(u = u->merged_into);
 565
 566         return u;
 567 }
 568
 569 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
 570         int r;
 571
 572         assert(u);
 573         assert(c);
 574
 575         if (c->std_output != EXEC_OUTPUT_KMSG &&
 576             c->std_output != EXEC_OUTPUT_SYSLOG &&
 577             c->std_output != EXEC_OUTPUT_JOURNAL &&
 578             c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
 579             c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
 580             c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
 581             c->std_error != EXEC_OUTPUT_KMSG &&
 582             c->std_error != EXEC_OUTPUT_SYSLOG &&
 583             c->std_error != EXEC_OUTPUT_JOURNAL &&
 584             c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
 585             c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
 586             c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
 587                 return 0;
 588
 589         /* If syslog or kernel logging is requested, make sure our own
 590          * logging daemon is run first. */
 591
 592         if (u->manager->running_as == MANAGER_SYSTEM)
 593                 if ((r = unit_add_two_dependencies_by_name(u, UNIT_REQUIRES, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true)) < 0)
 594                         return r;
 595
 596         return 0;
 597 }
 598
 599 const char *unit_description(Unit *u) {
 600         assert(u);
 601
 602         if (u->description)
 603                 return u->description;
 604
 605         return strna(u->id);
 606 }
 607
 608 void unit_dump(Unit *u, FILE *f, const char *prefix) {
 609         char *t;
 610         UnitDependency d;
 611         Iterator i;
 612         char *p2;
 613         const char *prefix2;
 614         char
 615                 timestamp1[FORMAT_TIMESTAMP_MAX],
 616                 timestamp2[FORMAT_TIMESTAMP_MAX],
 617                 timestamp3[FORMAT_TIMESTAMP_MAX],
 618                 timestamp4[FORMAT_TIMESTAMP_MAX],
 619                 timespan[FORMAT_TIMESPAN_MAX];
 620         Unit *following;
 621
 622         assert(u);
 623         assert(u->type >= 0);
 624
 625         if (!prefix)
 626                 prefix = "";
 627         p2 = strappend(prefix, "\t");
 628         prefix2 = p2 ? p2 : prefix;
 629
 630         fprintf(f,
 631                 "%s-> Unit %s:\n"
 632                 "%s\tDescription: %s\n"
 633                 "%s\tInstance: %s\n"
 634                 "%s\tUnit Load State: %s\n"
 635                 "%s\tUnit Active State: %s\n"
 636                 "%s\tInactive Exit Timestamp: %s\n"
 637                 "%s\tActive Enter Timestamp: %s\n"
 638                 "%s\tActive Exit Timestamp: %s\n"
 639                 "%s\tInactive Enter Timestamp: %s\n"
 640                 "%s\tGC Check Good: %s\n"
 641                 "%s\tNeed Daemon Reload: %s\n",
 642                 prefix, u->id,
 643                 prefix, unit_description(u),
 644                 prefix, strna(u->instance),
 645                 prefix, unit_load_state_to_string(u->load_state),
 646                 prefix, unit_active_state_to_string(unit_active_state(u)),
 647                 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
 648                 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
 649                 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
 650                 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
 651                 prefix, yes_no(unit_check_gc(u)),
 652                 prefix, yes_no(unit_need_daemon_reload(u)));
 653
 654         SET_FOREACH(t, u->names, i)
 655                 fprintf(f, "%s\tName: %s\n", prefix, t);
 656
 657         if ((following = unit_following(u)))
 658                 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
 659
 660         if (u->fragment_path)
 661                 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
 662
 663         if (u->job_timeout > 0)
 664                 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout));
 665
 666         condition_dump_list(u->conditions, f, prefix);
 667
 668         if (dual_timestamp_is_set(&u->condition_timestamp))
 669                 fprintf(f,
 670                         "%s\tCondition Timestamp: %s\n"
 671                         "%s\tCondition Result: %s\n",
 672                         prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
 673                         prefix, yes_no(u->condition_result));
 674
 675         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
 676                 Unit *other;
 677
 678                 SET_FOREACH(other, u->dependencies[d], i)
 679                         fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
 680         }
 681
 682         if (u->load_state == UNIT_LOADED) {
 683                 CGroupBonding *b;
 684                 CGroupAttribute *a;
 685
 686                 fprintf(f,
 687                         "%s\tStopWhenUnneeded: %s\n"
 688                         "%s\tRefuseManualStart: %s\n"
 689                         "%s\tRefuseManualStop: %s\n"
 690                         "%s\tDefaultDependencies: %s\n"
 691                         "%s\tOnFailureIsolate: %s\n"
 692                         "%s\tIgnoreOnIsolate: %s\n"
 693                         "%s\tIgnoreOnSnapshot: %s\n",
 694                         prefix, yes_no(u->stop_when_unneeded),
 695                         prefix, yes_no(u->refuse_manual_start),
 696                         prefix, yes_no(u->refuse_manual_stop),
 697                         prefix, yes_no(u->default_dependencies),
 698                         prefix, yes_no(u->on_failure_isolate),
 699                         prefix, yes_no(u->ignore_on_isolate),
 700                         prefix, yes_no(u->ignore_on_snapshot));
 701
 702                 LIST_FOREACH(by_unit, b, u->cgroup_bondings)
 703                         fprintf(f, "%s\tControlGroup: %s:%s\n",
 704                                 prefix, b->controller, b->path);
 705
 706                 LIST_FOREACH(by_unit, a, u->cgroup_attributes) {
 707                         char *v = NULL;
 708
 709                         if (a->map_callback)
 710                                 a->map_callback(a->controller, a->name, a->value, &v);
 711
 712                         fprintf(f, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
 713                                 prefix, a->controller, a->name, v ? v : a->value);
 714
 715                         free(v);
 716                 }
 717
 718                 if (UNIT_VTABLE(u)->dump)
 719                         UNIT_VTABLE(u)->dump(u, f, prefix2);
 720
 721         } else if (u->load_state == UNIT_MERGED)
 722                 fprintf(f,
 723                         "%s\tMerged into: %s\n",
 724                         prefix, u->merged_into->id);
 725         else if (u->load_state == UNIT_ERROR)
 726                 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
 727
 728
 729         if (u->job)
 730                 job_dump(u->job, f, prefix2);
 731
 732         free(p2);
 733 }
 734
 735 /* Common implementation for multiple backends */
 736 int unit_load_fragment_and_dropin(Unit *u) {
 737         int r;
 738
 739         assert(u);
 740
 741         /* Load a .service file */
 742         if ((r = unit_load_fragment(u)) < 0)
 743                 return r;
 744
 745         if (u->load_state == UNIT_STUB)
 746                 return -ENOENT;
 747
 748         /* Load drop-in directory data */
 749         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
 750                 return r;
 751
 752         return 0;
 753 }
 754
 755 /* Common implementation for multiple backends */
 756 int unit_load_fragment_and_dropin_optional(Unit *u) {
 757         int r;
 758
 759         assert(u);
 760
 761         /* Same as unit_load_fragment_and_dropin(), but whether
 762          * something can be loaded or not doesn't matter. */
 763
 764         /* Load a .service file */
 765         if ((r = unit_load_fragment(u)) < 0)
 766                 return r;
 767
 768         if (u->load_state == UNIT_STUB)
 769                 u->load_state = UNIT_LOADED;
 770
 771         /* Load drop-in directory data */
 772         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
 773                 return r;
 774
 775         return 0;
 776 }
 777
 778 int unit_add_default_target_dependency(Unit *u, Unit *target) {
 779         assert(u);
 780         assert(target);
 781
 782         if (target->type != UNIT_TARGET)
 783                 return 0;
 784
 785         /* Only add the dependency if both units are loaded, so that
 786          * that loop check below is reliable */
 787         if (u->load_state != UNIT_LOADED ||
 788             target->load_state != UNIT_LOADED)
 789                 return 0;
 790
 791         /* If either side wants no automatic dependencies, then let's
 792          * skip this */
 793         if (!u->default_dependencies ||
 794             !target->default_dependencies)
 795                 return 0;
 796
 797         /* Don't create loops */
 798         if (set_get(target->dependencies[UNIT_BEFORE], u))
 799                 return 0;
 800
 801         return unit_add_dependency(target, UNIT_AFTER, u, true);
 802 }
 803
 804 static int unit_add_default_dependencies(Unit *u) {
 805         static const UnitDependency deps[] = {
 806                 UNIT_REQUIRED_BY,
 807                 UNIT_REQUIRED_BY_OVERRIDABLE,
 808                 UNIT_WANTED_BY,
 809                 UNIT_BOUND_BY
 810         };
 811
 812         Unit *target;
 813         Iterator i;
 814         int r;
 815         unsigned k;
 816
 817         assert(u);
 818
 819         for (k = 0; k < ELEMENTSOF(deps); k++)
 820                 SET_FOREACH(target, u->dependencies[deps[k]], i)
 821                         if ((r = unit_add_default_target_dependency(u, target)) < 0)
 822                                 return r;
 823
 824         return 0;
 825 }
 826
 827 int unit_load(Unit *u) {
 828         int r;
 829
 830         assert(u);
 831
 832         if (u->in_load_queue) {
 833                 LIST_REMOVE(Unit, load_queue, u->manager->load_queue, u);
 834                 u->in_load_queue = false;
 835         }
 836
 837         if (u->type == _UNIT_TYPE_INVALID)
 838                 return -EINVAL;
 839
 840         if (u->load_state != UNIT_STUB)
 841                 return 0;
 842
 843         if (UNIT_VTABLE(u)->load)
 844                 if ((r = UNIT_VTABLE(u)->load(u)) < 0)
 845                         goto fail;
 846
 847         if (u->load_state == UNIT_STUB) {
 848                 r = -ENOENT;
 849                 goto fail;
 850         }
 851
 852         if (u->load_state == UNIT_LOADED &&
 853             u->default_dependencies)
 854                 if ((r = unit_add_default_dependencies(u)) < 0)
 855                         goto fail;
 856
 857         if (u->on_failure_isolate &&
 858             set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
 859
 860                 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
 861                           u->id);
 862
 863                 r = -EINVAL;
 864                 goto fail;
 865         }
 866
 867         assert((u->load_state != UNIT_MERGED) == !u->merged_into);
 868
 869         unit_add_to_dbus_queue(unit_follow_merge(u));
 870         unit_add_to_gc_queue(u);
 871
 872         return 0;
 873
 874 fail:
 875         u->load_state = UNIT_ERROR;
 876         u->load_error = r;
 877         unit_add_to_dbus_queue(u);
 878         unit_add_to_gc_queue(u);
 879
 880         log_debug("Failed to load configuration for %s: %s", u->id, strerror(-r));
 881
 882         return r;
 883 }
 884
 885 bool unit_condition_test(Unit *u) {
 886         assert(u);
 887
 888         dual_timestamp_get(&u->condition_timestamp);
 889         u->condition_result = condition_test_list(u->conditions);
 890
 891         return u->condition_result;
 892 }
 893
 894 /* Errors:
 895  *         -EBADR:     This unit type does not support starting.
 896  *         -EALREADY:  Unit is already started.
 897  *         -EAGAIN:    An operation is already in progress. Retry later.
 898  *         -ECANCELED: Too many requests for now.
 899  */
 900 int unit_start(Unit *u) {
 901         UnitActiveState state;
 902         Unit *following;
 903
 904         assert(u);
 905
 906         if (u->load_state != UNIT_LOADED)
 907                 return -EINVAL;
 908
 909         /* If this is already started, then this will succeed. Note
 910          * that this will even succeed if this unit is not startable
 911          * by the user. This is relied on to detect when we need to
 912          * wait for units and when waiting is finished. */
 913         state = unit_active_state(u);
 914         if (UNIT_IS_ACTIVE_OR_RELOADING(state))
 915                 return -EALREADY;
 916
 917         /* If the conditions failed, don't do anything at all. If we
 918          * already are activating this call might still be useful to
 919          * speed up activation in case there is some hold-off time,
 920          * but we don't want to recheck the condition in that case. */
 921         if (state != UNIT_ACTIVATING &&
 922             !unit_condition_test(u)) {
 923                 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
 924                 return -EALREADY;
 925         }
 926
 927         /* Forward to the main object, if we aren't it. */
 928         if ((following = unit_following(u))) {
 929                 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
 930                 return unit_start(following);
 931         }
 932
 933         /* If it is stopped, but we cannot start it, then fail */
 934         if (!UNIT_VTABLE(u)->start)
 935                 return -EBADR;
 936
 937         /* We don't suppress calls to ->start() here when we are
 938          * already starting, to allow this request to be used as a
 939          * "hurry up" call, for example when the unit is in some "auto
 940          * restart" state where it waits for a holdoff timer to elapse
 941          * before it will start again. */
 942
 943         unit_add_to_dbus_queue(u);
 944
 945         unit_status_printf(u, NULL, "Starting %s...", unit_description(u));
 946         return UNIT_VTABLE(u)->start(u);
 947 }
 948
 949 bool unit_can_start(Unit *u) {
 950         assert(u);
 951
 952         return !!UNIT_VTABLE(u)->start;
 953 }
 954
 955 bool unit_can_isolate(Unit *u) {
 956         assert(u);
 957
 958         return unit_can_start(u) &&
 959                 u->allow_isolate;
 960 }
 961
 962 /* Errors:
 963  *         -EBADR:    This unit type does not support stopping.
 964  *         -EALREADY: Unit is already stopped.
 965  *         -EAGAIN:   An operation is already in progress. Retry later.
 966  */
 967 int unit_stop(Unit *u) {
 968         UnitActiveState state;
 969         Unit *following;
 970
 971         assert(u);
 972
 973         state = unit_active_state(u);
 974         if (UNIT_IS_INACTIVE_OR_FAILED(state))
 975                 return -EALREADY;
 976
 977         if ((following = unit_following(u))) {
 978                 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
 979                 return unit_stop(following);
 980         }
 981
 982         if (!UNIT_VTABLE(u)->stop)
 983                 return -EBADR;
 984
 985         unit_add_to_dbus_queue(u);
 986
 987         unit_status_printf(u, NULL, "Stopping %s...", unit_description(u));
 988         return UNIT_VTABLE(u)->stop(u);
 989 }
 990
 991 /* Errors:
 992  *         -EBADR:    This unit type does not support reloading.
 993  *         -ENOEXEC:  Unit is not started.
 994  *         -EAGAIN:   An operation is already in progress. Retry later.
 995  */
 996 int unit_reload(Unit *u) {
 997         UnitActiveState state;
 998         Unit *following;
 999
1000         assert(u);
1001
1002         if (u->load_state != UNIT_LOADED)
1003                 return -EINVAL;
1004
1005         if (!unit_can_reload(u))
1006                 return -EBADR;
1007
1008         state = unit_active_state(u);
1009         if (state == UNIT_RELOADING)
1010                 return -EALREADY;
1011
1012         if (state != UNIT_ACTIVE)
1013                 return -ENOEXEC;
1014
1015         if ((following = unit_following(u))) {
1016                 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1017                 return unit_reload(following);
1018         }
1019
1020         unit_add_to_dbus_queue(u);
1021         return UNIT_VTABLE(u)->reload(u);
1022 }
1023
1024 bool unit_can_reload(Unit *u) {
1025         assert(u);
1026
1027         if (!UNIT_VTABLE(u)->reload)
1028                 return false;
1029
1030         if (!UNIT_VTABLE(u)->can_reload)
1031                 return true;
1032
1033         return UNIT_VTABLE(u)->can_reload(u);
1034 }
1035
1036 static void unit_check_unneeded(Unit *u) {
1037         Iterator i;
1038         Unit *other;
1039
1040         assert(u);
1041
1042         /* If this service shall be shut down when unneeded then do
1043          * so. */
1044
1045         if (!u->stop_when_unneeded)
1046                 return;
1047
1048         if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1049                 return;
1050
1051         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1052                 if (unit_pending_active(other))
1053                         return;
1054
1055         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1056                 if (unit_pending_active(other))
1057                         return;
1058
1059         SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1060                 if (unit_pending_active(other))
1061                         return;
1062
1063         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1064                 if (unit_pending_active(other))
1065                         return;
1066
1067         log_info("Service %s is not needed anymore. Stopping.", u->id);
1068
1069         /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1070         manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1071 }
1072
1073 static void retroactively_start_dependencies(Unit *u) {
1074         Iterator i;
1075         Unit *other;
1076
1077         assert(u);
1078         assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1079
1080         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1081                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1082                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1083                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1084
1085         SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1086                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1087                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1088                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1089
1090         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1091                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1092                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1093                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1094
1095         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1096                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1097                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1098                         manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1099
1100         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1101                 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1102                     !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1103                         manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1104
1105         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1106                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1107                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1108
1109         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1110                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1111                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1112 }
1113
1114 static void retroactively_stop_dependencies(Unit *u) {
1115         Iterator i;
1116         Unit *other;
1117
1118         assert(u);
1119         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1120
1121         /* Pull down units which are bound to us recursively if enabled */
1122         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1123                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1124                         manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1125 }
1126
1127 static void check_unneeded_dependencies(Unit *u) {
1128         Iterator i;
1129         Unit *other;
1130
1131         assert(u);
1132         assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1133
1134         /* Garbage collect services that might not be needed anymore, if enabled */
1135         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1136                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1137                         unit_check_unneeded(other);
1138         SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1139                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1140                         unit_check_unneeded(other);
1141         SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1142                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1143                         unit_check_unneeded(other);
1144         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1145                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1146                         unit_check_unneeded(other);
1147         SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1148                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1149                         unit_check_unneeded(other);
1150         SET_FOREACH(other, u->dependencies[UNIT_BIND_TO], i)
1151                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1152                         unit_check_unneeded(other);
1153 }
1154
1155 void unit_trigger_on_failure(Unit *u) {
1156         Unit *other;
1157         Iterator i;
1158
1159         assert(u);
1160
1161         if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1162                 return;
1163
1164         log_info("Triggering OnFailure= dependencies of %s.", u->id);
1165
1166         SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1167                 int r;
1168
1169                 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1170                         log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1171         }
1172 }
1173
1174 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1175         bool unexpected;
1176
1177         assert(u);
1178         assert(os < _UNIT_ACTIVE_STATE_MAX);
1179         assert(ns < _UNIT_ACTIVE_STATE_MAX);
1180
1181         /* Note that this is called for all low-level state changes,
1182          * even if they might map to the same high-level
1183          * UnitActiveState! That means that ns == os is OK an expected
1184          * behaviour here. For example: if a mount point is remounted
1185          * this function will be called too! */
1186
1187         if (u->manager->n_reloading <= 0) {
1188                 dual_timestamp ts;
1189
1190                 dual_timestamp_get(&ts);
1191
1192                 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1193                         u->inactive_exit_timestamp = ts;
1194                 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1195                         u->inactive_enter_timestamp = ts;
1196
1197                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1198                         u->active_enter_timestamp = ts;
1199                 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1200                         u->active_exit_timestamp = ts;
1201
1202                 timer_unit_notify(u, ns);
1203                 path_unit_notify(u, ns);
1204         }
1205
1206         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1207                 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1208
1209         if (u->job) {
1210                 unexpected = false;
1211
1212                 if (u->job->state == JOB_WAITING)
1213
1214                         /* So we reached a different state for this
1215                          * job. Let's see if we can run it now if it
1216                          * failed previously due to EAGAIN. */
1217                         job_add_to_run_queue(u->job);
1218
1219                 /* Let's check whether this state change constitutes a
1220                  * finished job, or maybe contradicts a running job and
1221                  * hence needs to invalidate jobs. */
1222
1223                 switch (u->job->type) {
1224
1225                 case JOB_START:
1226                 case JOB_VERIFY_ACTIVE:
1227
1228                         if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1229                                 job_finish_and_invalidate(u->job, JOB_DONE);
1230                         else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1231                                 unexpected = true;
1232
1233                                 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1234                                         job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE);
1235                         }
1236
1237                         break;
1238
1239                 case JOB_RELOAD:
1240                 case JOB_RELOAD_OR_START:
1241
1242                         if (u->job->state == JOB_RUNNING) {
1243                                 if (ns == UNIT_ACTIVE)
1244                                         job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED);
1245                                 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1246                                         unexpected = true;
1247
1248                                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1249                                                 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE);
1250                                 }
1251                         }
1252
1253                         break;
1254
1255                 case JOB_STOP:
1256                 case JOB_RESTART:
1257                 case JOB_TRY_RESTART:
1258
1259                         if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1260                                 job_finish_and_invalidate(u->job, JOB_DONE);
1261                         else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1262                                 unexpected = true;
1263                                 job_finish_and_invalidate(u->job, JOB_FAILED);
1264                         }
1265
1266                         break;
1267
1268                 default:
1269                         assert_not_reached("Job type unknown");
1270                 }
1271
1272         } else
1273                 unexpected = true;
1274
1275         if (u->manager->n_reloading <= 0) {
1276
1277                 /* If this state change happened without being
1278                  * requested by a job, then let's retroactively start
1279                  * or stop dependencies. We skip that step when
1280                  * deserializing, since we don't want to create any
1281                  * additional jobs just because something is already
1282                  * activated. */
1283
1284                 if (unexpected) {
1285                         if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1286                                 retroactively_start_dependencies(u);
1287                         else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1288                                 retroactively_stop_dependencies(u);
1289                 }
1290
1291                 /* stop unneeded units regardless if going down was expected or not */
1292                 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1293                         check_unneeded_dependencies(u);
1294
1295                 if (ns != os && ns == UNIT_FAILED) {
1296                         log_notice("Unit %s entered failed state.", u->id);
1297                         unit_trigger_on_failure(u);
1298                 }
1299         }
1300
1301         /* Some names are special */
1302         if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1303
1304                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1305                         /* The bus just might have become available,
1306                          * hence try to connect to it, if we aren't
1307                          * yet connected. */
1308                         bus_init(u->manager, true);
1309
1310                 if (u->type == UNIT_SERVICE &&
1311                     !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1312                     u->manager->n_reloading <= 0) {
1313                         /* Write audit record if we have just finished starting up */
1314                         manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
1315                         u->in_audit = true;
1316                 }
1317
1318                 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1319                         manager_send_unit_plymouth(u->manager, u);
1320
1321         } else {
1322
1323                 /* We don't care about D-Bus here, since we'll get an
1324                  * asynchronous notification for it anyway. */
1325
1326                 if (u->type == UNIT_SERVICE &&
1327                     UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1328                     !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1329                     u->manager->n_reloading <= 0) {
1330
1331                         /* Hmm, if there was no start record written
1332                          * write it now, so that we always have a nice
1333                          * pair */
1334                         if (!u->in_audit) {
1335                                 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1336
1337                                 if (ns == UNIT_INACTIVE)
1338                                         manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
1339                         } else
1340                                 /* Write audit record if we have just finished shutting down */
1341                                 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1342
1343                         u->in_audit = false;
1344                 }
1345         }
1346
1347         manager_recheck_journal(u->manager);
1348
1349         /* Maybe we finished startup and are now ready for being
1350          * stopped because unneeded? */
1351         unit_check_unneeded(u);
1352
1353         unit_add_to_dbus_queue(u);
1354         unit_add_to_gc_queue(u);
1355 }
1356
1357 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1358         struct epoll_event ev;
1359
1360         assert(u);
1361         assert(fd >= 0);
1362         assert(w);
1363         assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1364
1365         zero(ev);
1366         ev.data.ptr = w;
1367         ev.events = events;
1368
1369         if (epoll_ctl(u->manager->epoll_fd,
1370                       w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1371                       fd,
1372                       &ev) < 0)
1373                 return -errno;
1374
1375         w->fd = fd;
1376         w->type = WATCH_FD;
1377         w->data.unit = u;
1378
1379         return 0;
1380 }
1381
1382 void unit_unwatch_fd(Unit *u, Watch *w) {
1383         assert(u);
1384         assert(w);
1385
1386         if (w->type == WATCH_INVALID)
1387                 return;
1388
1389         assert(w->type == WATCH_FD);
1390         assert(w->data.unit == u);
1391         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1392
1393         w->fd = -1;
1394         w->type = WATCH_INVALID;
1395         w->data.unit = NULL;
1396 }
1397
1398 int unit_watch_pid(Unit *u, pid_t pid) {
1399         assert(u);
1400         assert(pid >= 1);
1401
1402         /* Watch a specific PID. We only support one unit watching
1403          * each PID for now. */
1404
1405         return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1406 }
1407
1408 void unit_unwatch_pid(Unit *u, pid_t pid) {
1409         assert(u);
1410         assert(pid >= 1);
1411
1412         hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1413 }
1414
1415 int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
1416         struct itimerspec its;
1417         int flags, fd;
1418         bool ours;
1419
1420         assert(u);
1421         assert(w);
1422         assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1423
1424         /* This will try to reuse the old timer if there is one */
1425
1426         if (w->type == WATCH_UNIT_TIMER) {
1427                 assert(w->data.unit == u);
1428                 assert(w->fd >= 0);
1429
1430                 ours = false;
1431                 fd = w->fd;
1432         } else if (w->type == WATCH_INVALID) {
1433
1434                 ours = true;
1435                 if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
1436                         return -errno;
1437         } else
1438                 assert_not_reached("Invalid watch type");
1439
1440         zero(its);
1441
1442         if (delay <= 0) {
1443                 /* Set absolute time in the past, but not 0, since we
1444                  * don't want to disarm the timer */
1445                 its.it_value.tv_sec = 0;
1446                 its.it_value.tv_nsec = 1;
1447
1448                 flags = TFD_TIMER_ABSTIME;
1449         } else {
1450                 timespec_store(&its.it_value, delay);
1451                 flags = 0;
1452         }
1453
1454         /* This will also flush the elapse counter */
1455         if (timerfd_settime(fd, flags, &its, NULL) < 0)
1456                 goto fail;
1457
1458         if (w->type == WATCH_INVALID) {
1459                 struct epoll_event ev;
1460
1461                 zero(ev);
1462                 ev.data.ptr = w;
1463                 ev.events = EPOLLIN;
1464
1465                 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1466                         goto fail;
1467         }
1468
1469         w->type = WATCH_UNIT_TIMER;
1470         w->fd = fd;
1471         w->data.unit = u;
1472
1473         return 0;
1474
1475 fail:
1476         if (ours)
1477                 close_nointr_nofail(fd);
1478
1479         return -errno;
1480 }
1481
1482 void unit_unwatch_timer(Unit *u, Watch *w) {
1483         assert(u);
1484         assert(w);
1485
1486         if (w->type == WATCH_INVALID)
1487                 return;
1488
1489         assert(w->type == WATCH_UNIT_TIMER);
1490         assert(w->data.unit == u);
1491         assert(w->fd >= 0);
1492
1493         assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1494         close_nointr_nofail(w->fd);
1495
1496         w->fd = -1;
1497         w->type = WATCH_INVALID;
1498         w->data.unit = NULL;
1499 }
1500
1501 bool unit_job_is_applicable(Unit *u, JobType j) {
1502         assert(u);
1503         assert(j >= 0 && j < _JOB_TYPE_MAX);
1504
1505         switch (j) {
1506
1507         case JOB_VERIFY_ACTIVE:
1508         case JOB_START:
1509         case JOB_STOP:
1510                 return true;
1511
1512         case JOB_RESTART:
1513         case JOB_TRY_RESTART:
1514                 return unit_can_start(u);
1515
1516         case JOB_RELOAD:
1517                 return unit_can_reload(u);
1518
1519         case JOB_RELOAD_OR_START:
1520                 return unit_can_reload(u) && unit_can_start(u);
1521
1522         default:
1523                 assert_not_reached("Invalid job type");
1524         }
1525 }
1526
1527 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1528
1529         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1530                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1531                 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1532                 [UNIT_WANTS] = UNIT_WANTED_BY,
1533                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1534                 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1535                 [UNIT_BIND_TO] = UNIT_BOUND_BY,
1536                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1537                 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1538                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1539                 [UNIT_BOUND_BY] = UNIT_BIND_TO,
1540                 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1541                 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1542                 [UNIT_BEFORE] = UNIT_AFTER,
1543                 [UNIT_AFTER] = UNIT_BEFORE,
1544                 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1545                 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1546                 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1547                 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1548                 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1549                 [UNIT_PROPAGATE_RELOAD_TO] = UNIT_PROPAGATE_RELOAD_FROM,
1550                 [UNIT_PROPAGATE_RELOAD_FROM] = UNIT_PROPAGATE_RELOAD_TO
1551         };
1552         int r, q = 0, v = 0, w = 0;
1553
1554         assert(u);
1555         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1556         assert(other);
1557
1558         u = unit_follow_merge(u);
1559         other = unit_follow_merge(other);
1560
1561         /* We won't allow dependencies on ourselves. We will not
1562          * consider them an error however. */
1563         if (u == other)
1564                 return 0;
1565
1566         if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1567                 return r;
1568
1569         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1570                 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1571                         return r;
1572
1573         if (add_reference)
1574                 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1575                     (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1576                         return r;
1577
1578         if ((q = set_put(u->dependencies[d], other)) < 0)
1579                 return q;
1580
1581         if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1582                 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1583                         r = v;
1584                         goto fail;
1585                 }
1586
1587         if (add_reference) {
1588                 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1589                         r = w;
1590                         goto fail;
1591                 }
1592
1593                 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1594                         goto fail;
1595         }
1596
1597         unit_add_to_dbus_queue(u);
1598         return 0;
1599
1600 fail:
1601         if (q > 0)
1602                 set_remove(u->dependencies[d], other);
1603
1604         if (v > 0)
1605                 set_remove(other->dependencies[inverse_table[d]], u);
1606
1607         if (w > 0)
1608                 set_remove(u->dependencies[UNIT_REFERENCES], other);
1609
1610         return r;
1611 }
1612
1613 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1614         int r;
1615
1616         assert(u);
1617
1618         if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1619                 return r;
1620
1621         if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1622                 return r;
1623
1624         return 0;
1625 }
1626
1627 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1628         char *s;
1629
1630         assert(u);
1631         assert(name || path);
1632
1633         if (!name)
1634                 name = file_name_from_path(path);
1635
1636         if (!unit_name_is_template(name)) {
1637                 *p = NULL;
1638                 return name;
1639         }
1640
1641         if (u->instance)
1642                 s = unit_name_replace_instance(name, u->instance);
1643         else {
1644                 char *i;
1645
1646                 if (!(i = unit_name_to_prefix(u->id)))
1647                         return NULL;
1648
1649                 s = unit_name_replace_instance(name, i);
1650                 free(i);
1651         }
1652
1653         if (!s)
1654                 return NULL;
1655
1656         *p = s;
1657         return s;
1658 }
1659
1660 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1661         Unit *other;
1662         int r;
1663         char *s;
1664
1665         assert(u);
1666         assert(name || path);
1667
1668         if (!(name = resolve_template(u, name, path, &s)))
1669                 return -ENOMEM;
1670
1671         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1672                 goto finish;
1673
1674         r = unit_add_dependency(u, d, other, add_reference);
1675
1676 finish:
1677         free(s);
1678         return r;
1679 }
1680
1681 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1682         Unit *other;
1683         int r;
1684         char *s;
1685
1686         assert(u);
1687         assert(name || path);
1688
1689         if (!(name = resolve_template(u, name, path, &s)))
1690                 return -ENOMEM;
1691
1692         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1693                 goto finish;
1694
1695         r = unit_add_two_dependencies(u, d, e, other, add_reference);
1696
1697 finish:
1698         free(s);
1699         return r;
1700 }
1701
1702 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1703         Unit *other;
1704         int r;
1705         char *s;
1706
1707         assert(u);
1708         assert(name || path);
1709
1710         if (!(name = resolve_template(u, name, path, &s)))
1711                 return -ENOMEM;
1712
1713         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1714                 goto finish;
1715
1716         r = unit_add_dependency(other, d, u, add_reference);
1717
1718 finish:
1719         free(s);
1720         return r;
1721 }
1722
1723 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1724         Unit *other;
1725         int r;
1726         char *s;
1727
1728         assert(u);
1729         assert(name || path);
1730
1731         if (!(name = resolve_template(u, name, path, &s)))
1732                 return -ENOMEM;
1733
1734         if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1735                 goto finish;
1736
1737         if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1738                 goto finish;
1739
1740 finish:
1741         free(s);
1742         return r;
1743 }
1744
1745 int set_unit_path(const char *p) {
1746         char *cwd, *c;
1747         int r;
1748
1749         /* This is mostly for debug purposes */
1750
1751         if (path_is_absolute(p)) {
1752                 if (!(c = strdup(p)))
1753                         return -ENOMEM;
1754         } else {
1755                 if (!(cwd = get_current_dir_name()))
1756                         return -errno;
1757
1758                 r = asprintf(&c, "%s/%s", cwd, p);
1759                 free(cwd);
1760
1761                 if (r < 0)
1762                         return -ENOMEM;
1763         }
1764
1765         if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0) {
1766                 r = -errno;
1767                 free(c);
1768                 return r;
1769         }
1770
1771         return 0;
1772 }
1773
1774 char *unit_dbus_path(Unit *u) {
1775         char *p, *e;
1776
1777         assert(u);
1778
1779         if (!u->id)
1780                 return NULL;
1781
1782         if (!(e = bus_path_escape(u->id)))
1783                 return NULL;
1784
1785         p = strappend("/org/freedesktop/systemd1/unit/", e);
1786         free(e);
1787
1788         return p;
1789 }
1790
1791 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1792         int r;
1793
1794         assert(u);
1795         assert(b);
1796
1797         assert(b->path);
1798
1799         if (!b->controller) {
1800                 if (!(b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER)))
1801                         return -ENOMEM;
1802
1803                 b->ours = true;
1804         }
1805
1806         /* Ensure this hasn't been added yet */
1807         assert(!b->unit);
1808
1809         if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1810                 CGroupBonding *l;
1811
1812                 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1813                 LIST_PREPEND(CGroupBonding, by_path, l, b);
1814
1815                 if ((r = hashmap_replace(u->manager->cgroup_bondings, b->path, l)) < 0) {
1816                         LIST_REMOVE(CGroupBonding, by_path, l, b);
1817                         return r;
1818                 }
1819         }
1820
1821         LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1822         b->unit = u;
1823
1824         return 0;
1825 }
1826
1827 static char *default_cgroup_path(Unit *u) {
1828         char *p;
1829
1830         assert(u);
1831
1832         if (u->instance) {
1833                 char *t;
1834
1835                 t = unit_name_template(u->id);
1836                 if (!t)
1837                         return NULL;
1838
1839                 p = join(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1840                 free(t);
1841         } else
1842                 p = join(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1843
1844         return p;
1845 }
1846
1847 int unit_add_cgroup_from_text(Unit *u, const char *name) {
1848         char *controller = NULL, *path = NULL;
1849         CGroupBonding *b = NULL;
1850         bool ours = false;
1851         int r;
1852
1853         assert(u);
1854         assert(name);
1855
1856         if ((r = cg_split_spec(name, &controller, &path)) < 0)
1857                 return r;
1858
1859         if (!path) {
1860                 path = default_cgroup_path(u);
1861                 ours = true;
1862         }
1863
1864         if (!controller) {
1865                 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1866                 ours = true;
1867         }
1868
1869         if (!path || !controller) {
1870                 free(path);
1871                 free(controller);
1872
1873                 return -ENOMEM;
1874         }
1875
1876         if (cgroup_bonding_find_list(u->cgroup_bondings, controller)) {
1877                 r = -EEXIST;
1878                 goto fail;
1879         }
1880
1881         if (!(b = new0(CGroupBonding, 1))) {
1882                 r = -ENOMEM;
1883                 goto fail;
1884         }
1885
1886         b->controller = controller;
1887         b->path = path;
1888         b->ours = ours;
1889         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1890
1891         if ((r = unit_add_cgroup(u, b)) < 0)
1892                 goto fail;
1893
1894         return 0;
1895
1896 fail:
1897         free(path);
1898         free(controller);
1899         free(b);
1900
1901         return r;
1902 }
1903
1904 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
1905         CGroupBonding *b = NULL;
1906         int r = -ENOMEM;
1907
1908         assert(u);
1909
1910         if (!controller)
1911                 controller = SYSTEMD_CGROUP_CONTROLLER;
1912
1913         if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
1914                 return 0;
1915
1916         if (!(b = new0(CGroupBonding, 1)))
1917                 return -ENOMEM;
1918
1919         if (!(b->controller = strdup(controller)))
1920                 goto fail;
1921
1922         if (!(b->path = default_cgroup_path(u)))
1923                 goto fail;
1924
1925         b->ours = true;
1926         b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
1927
1928         if ((r = unit_add_cgroup(u, b)) < 0)
1929                 goto fail;
1930
1931         return 0;
1932
1933 fail:
1934         free(b->path);
1935         free(b->controller);
1936         free(b);
1937
1938         return r;
1939 }
1940
1941 int unit_add_default_cgroups(Unit *u) {
1942         CGroupAttribute *a;
1943         char **c;
1944         int r;
1945
1946         assert(u);
1947
1948         /* Adds in the default cgroups, if they weren't specified
1949          * otherwise. */
1950
1951         if (!u->manager->cgroup_hierarchy)
1952                 return 0;
1953
1954         if ((r = unit_add_one_default_cgroup(u, NULL)) < 0)
1955                 return r;
1956
1957         STRV_FOREACH(c, u->manager->default_controllers)
1958                 unit_add_one_default_cgroup(u, *c);
1959
1960         LIST_FOREACH(by_unit, a, u->cgroup_attributes)
1961                 unit_add_one_default_cgroup(u, a->controller);
1962
1963         return 0;
1964 }
1965
1966 CGroupBonding* unit_get_default_cgroup(Unit *u) {
1967         assert(u);
1968
1969         return cgroup_bonding_find_list(u->cgroup_bondings, SYSTEMD_CGROUP_CONTROLLER);
1970 }
1971
1972 int unit_add_cgroup_attribute(Unit *u, const char *controller, const char *name, const char *value, CGroupAttributeMapCallback map_callback) {
1973         int r;
1974         char *c = NULL;
1975         CGroupAttribute *a;
1976
1977         assert(u);
1978         assert(name);
1979         assert(value);
1980
1981         if (!controller) {
1982                 const char *dot;
1983
1984                 dot = strchr(name, '.');
1985                 if (!dot)
1986                         return -EINVAL;
1987
1988                 c = strndup(name, dot - name);
1989                 if (!c)
1990                         return -ENOMEM;
1991
1992                 controller = c;
1993         }
1994
1995         if (streq(controller, SYSTEMD_CGROUP_CONTROLLER)) {
1996                 r = -EINVAL;
1997                 goto finish;
1998         }
1999
2000         a = new0(CGroupAttribute, 1);
2001         if (!a) {
2002                 r = -ENOMEM;
2003                 goto finish;
2004         }
2005
2006         if (c) {
2007                 a->controller = c;
2008                 c = NULL;
2009         } else
2010                 a->controller = strdup(controller);
2011
2012         a->name = strdup(name);
2013         a->value = strdup(value);
2014
2015         if (!a->controller || !a->name || !a->value) {
2016                 free(a->controller);
2017                 free(a->name);
2018                 free(a->value);
2019                 free(a);
2020
2021                 return -ENOMEM;
2022         }
2023
2024         a->map_callback = map_callback;
2025
2026         LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2027
2028         r = 0;
2029
2030 finish:
2031         free(c);
2032         return r;
2033 }
2034
2035 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2036         char *t;
2037         int r;
2038
2039         assert(u);
2040         assert(type);
2041         assert(_found);
2042
2043         if (!(t = unit_name_change_suffix(u->id, type)))
2044                 return -ENOMEM;
2045
2046         assert(!unit_has_name(u, t));
2047
2048         r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2049         free(t);
2050
2051         assert(r < 0 || *_found != u);
2052
2053         return r;
2054 }
2055
2056 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2057         Unit *found;
2058         char *t;
2059
2060         assert(u);
2061         assert(type);
2062         assert(_found);
2063
2064         if (!(t = unit_name_change_suffix(u->id, type)))
2065                 return -ENOMEM;
2066
2067         assert(!unit_has_name(u, t));
2068
2069         found = manager_get_unit(u->manager, t);
2070         free(t);
2071
2072         if (!found)
2073                 return -ENOENT;
2074
2075         *_found = found;
2076         return 0;
2077 }
2078
2079 static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
2080         Unit *u = userdata;
2081         assert(u);
2082
2083         return unit_name_to_prefix_and_instance(u->id);
2084 }
2085
2086 static char *specifier_prefix(char specifier, void *data, void *userdata) {
2087         Unit *u = userdata;
2088         assert(u);
2089
2090         return unit_name_to_prefix(u->id);
2091 }
2092
2093 static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
2094         Unit *u = userdata;
2095         char *p, *r;
2096
2097         assert(u);
2098
2099         if (!(p = unit_name_to_prefix(u->id)))
2100                 return NULL;
2101
2102         r = unit_name_unescape(p);
2103         free(p);
2104
2105         return r;
2106 }
2107
2108 static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
2109         Unit *u = userdata;
2110         assert(u);
2111
2112         if (u->instance)
2113                 return unit_name_unescape(u->instance);
2114
2115         return strdup("");
2116 }
2117
2118 static char *specifier_filename(char specifier, void *data, void *userdata) {
2119         Unit *u = userdata;
2120         assert(u);
2121
2122         if (u->instance)
2123                 return unit_name_path_unescape(u->instance);
2124
2125         return unit_name_to_path(u->instance);
2126 }
2127
2128 static char *specifier_cgroup(char specifier, void *data, void *userdata) {
2129         Unit *u = userdata;
2130         assert(u);
2131
2132         return default_cgroup_path(u);
2133 }
2134
2135 static char *specifier_cgroup_root(char specifier, void *data, void *userdata) {
2136         Unit *u = userdata;
2137         char *p;
2138         assert(u);
2139
2140         if (specifier == 'r')
2141                 return strdup(u->manager->cgroup_hierarchy);
2142
2143         if (parent_of_path(u->manager->cgroup_hierarchy, &p) < 0)
2144                 return strdup("");
2145
2146         if (streq(p, "/")) {
2147                 free(p);
2148                 return strdup("");
2149         }
2150
2151         return p;
2152 }
2153
2154 static char *specifier_runtime(char specifier, void *data, void *userdata) {
2155         Unit *u = userdata;
2156         assert(u);
2157
2158         if (u->manager->running_as == MANAGER_USER) {
2159                 const char *e;
2160
2161                 e = getenv("XDG_RUNTIME_DIR");
2162                 if (e)
2163                         return strdup(e);
2164         }
2165
2166         return strdup("/run");
2167 }
2168
2169 char *unit_name_printf(Unit *u, const char* format) {
2170
2171         /*
2172          * This will use the passed string as format string and
2173          * replace the following specifiers:
2174          *
2175          * %n: the full id of the unit                 (foo@bar.waldo)
2176          * %N: the id of the unit without the suffix   (foo@bar)
2177          * %p: the prefix                              (foo)
2178          * %i: the instance                            (bar)
2179          */
2180
2181         const Specifier table[] = {
2182                 { 'n', specifier_string,              u->id },
2183                 { 'N', specifier_prefix_and_instance, NULL },
2184                 { 'p', specifier_prefix,              NULL },
2185                 { 'i', specifier_string,              u->instance },
2186                 { 0, NULL, NULL }
2187         };
2188
2189         assert(u);
2190         assert(format);
2191
2192         return specifier_printf(format, table, u);
2193 }
2194
2195 char *unit_full_printf(Unit *u, const char *format) {
2196
2197         /* This is similar to unit_name_printf() but also supports
2198          * unescaping. Also, adds a couple of additional codes:
2199          *
2200          * %c cgroup path of unit
2201          * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
2202          * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
2203          * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
2204          */
2205
2206         const Specifier table[] = {
2207                 { 'n', specifier_string,              u->id },
2208                 { 'N', specifier_prefix_and_instance, NULL },
2209                 { 'p', specifier_prefix,              NULL },
2210                 { 'P', specifier_prefix_unescaped,    NULL },
2211                 { 'i', specifier_string,              u->instance },
2212                 { 'I', specifier_instance_unescaped,  NULL },
2213                 { 'f', specifier_filename,            NULL },
2214                 { 'c', specifier_cgroup,              NULL },
2215                 { 'r', specifier_cgroup_root,         NULL },
2216                 { 'R', specifier_cgroup_root,         NULL },
2217                 { 't', specifier_runtime,             NULL },
2218                 { 0, NULL, NULL }
2219         };
2220
2221         assert(u);
2222         assert(format);
2223
2224         return specifier_printf(format, table, u);
2225 }
2226
2227 char **unit_full_printf_strv(Unit *u, char **l) {
2228         size_t n;
2229         char **r, **i, **j;
2230
2231         /* Applies unit_full_printf to every entry in l */
2232
2233         assert(u);
2234
2235         n = strv_length(l);
2236         if (!(r = new(char*, n+1)))
2237                 return NULL;
2238
2239         for (i = l, j = r; *i; i++, j++)
2240                 if (!(*j = unit_full_printf(u, *i)))
2241                         goto fail;
2242
2243         *j = NULL;
2244         return r;
2245
2246 fail:
2247         for (j--; j >= r; j--)
2248                 free(*j);
2249
2250         free(r);
2251
2252         return NULL;
2253 }
2254
2255 int unit_watch_bus_name(Unit *u, const char *name) {
2256         assert(u);
2257         assert(name);
2258
2259         /* Watch a specific name on the bus. We only support one unit
2260          * watching each name for now. */
2261
2262         return hashmap_put(u->manager->watch_bus, name, u);
2263 }
2264
2265 void unit_unwatch_bus_name(Unit *u, const char *name) {
2266         assert(u);
2267         assert(name);
2268
2269         hashmap_remove_value(u->manager->watch_bus, name, u);
2270 }
2271
2272 bool unit_can_serialize(Unit *u) {
2273         assert(u);
2274
2275         return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2276 }
2277
2278 int unit_serialize(Unit *u, FILE *f, FDSet *fds) {
2279         int r;
2280
2281         assert(u);
2282         assert(f);
2283         assert(fds);
2284
2285         if (!unit_can_serialize(u))
2286                 return 0;
2287
2288         if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2289                 return r;
2290
2291         if (u->job)
2292                 unit_serialize_item(u, f, "job", job_type_to_string(u->job->type));
2293
2294         dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2295         dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2296         dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2297         dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2298         dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2299
2300         if (dual_timestamp_is_set(&u->condition_timestamp))
2301                 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2302
2303         /* End marker */
2304         fputc('\n', f);
2305         return 0;
2306 }
2307
2308 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2309         va_list ap;
2310
2311         assert(u);
2312         assert(f);
2313         assert(key);
2314         assert(format);
2315
2316         fputs(key, f);
2317         fputc('=', f);
2318
2319         va_start(ap, format);
2320         vfprintf(f, format, ap);
2321         va_end(ap);
2322
2323         fputc('\n', f);
2324 }
2325
2326 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2327         assert(u);
2328         assert(f);
2329         assert(key);
2330         assert(value);
2331
2332         fprintf(f, "%s=%s\n", key, value);
2333 }
2334
2335 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2336         int r;
2337
2338         assert(u);
2339         assert(f);
2340         assert(fds);
2341
2342         if (!unit_can_serialize(u))
2343                 return 0;
2344
2345         for (;;) {
2346                 char line[LINE_MAX], *l, *v;
2347                 size_t k;
2348
2349                 if (!fgets(line, sizeof(line), f)) {
2350                         if (feof(f))
2351                                 return 0;
2352                         return -errno;
2353                 }
2354
2355                 char_array_0(line);
2356                 l = strstrip(line);
2357
2358                 /* End marker */
2359                 if (l[0] == 0)
2360                         return 0;
2361
2362                 k = strcspn(l, "=");
2363
2364                 if (l[k] == '=') {
2365                         l[k] = 0;
2366                         v = l+k+1;
2367                 } else
2368                         v = l+k;
2369
2370                 if (streq(l, "job")) {
2371                         JobType type;
2372
2373                         if ((type = job_type_from_string(v)) < 0)
2374                                 log_debug("Failed to parse job type value %s", v);
2375                         else
2376                                 u->deserialized_job = type;
2377
2378                         continue;
2379                 } else if (streq(l, "inactive-exit-timestamp")) {
2380                         dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2381                         continue;
2382                 } else if (streq(l, "active-enter-timestamp")) {
2383                         dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2384                         continue;
2385                 } else if (streq(l, "active-exit-timestamp")) {
2386                         dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2387                         continue;
2388                 } else if (streq(l, "inactive-enter-timestamp")) {
2389                         dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2390                         continue;
2391                 } else if (streq(l, "condition-timestamp")) {
2392                         dual_timestamp_deserialize(v, &u->condition_timestamp);
2393                         continue;
2394                 } else if (streq(l, "condition-result")) {
2395                         int b;
2396
2397                         if ((b = parse_boolean(v)) < 0)
2398                                 log_debug("Failed to parse condition result value %s", v);
2399                         else
2400                                 u->condition_result = b;
2401
2402                         continue;
2403                 }
2404
2405                 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2406                         return r;
2407         }
2408 }
2409
2410 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2411         Unit *device;
2412         char *e;
2413         int r;
2414
2415         assert(u);
2416
2417         if (!what)
2418                 return 0;
2419
2420         /* Adds in links to the device node that this unit is based on */
2421
2422         if (!is_device_path(what))
2423                 return 0;
2424
2425         if (!(e = unit_name_build_escape(what+1, NULL, ".device")))
2426                 return -ENOMEM;
2427
2428         r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2429         free(e);
2430
2431         if (r < 0)
2432                 return r;
2433
2434         if ((r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BIND_TO, device, true)) < 0)
2435                 return r;
2436
2437         if (wants)
2438                 if ((r = unit_add_dependency(device, UNIT_WANTS, u, false)) < 0)
2439                         return r;
2440
2441         return 0;
2442 }
2443
2444 int unit_coldplug(Unit *u) {
2445         int r;
2446
2447         assert(u);
2448
2449         if (UNIT_VTABLE(u)->coldplug)
2450                 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2451                         return r;
2452
2453         if (u->deserialized_job >= 0) {
2454                 if ((r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL)) < 0)
2455                         return r;
2456
2457                 u->deserialized_job = _JOB_TYPE_INVALID;
2458         }
2459
2460         return 0;
2461 }
2462
2463 void unit_status_printf(Unit *u, const char *status, const char *format, ...) {
2464         va_list ap;
2465
2466         assert(u);
2467         assert(format);
2468
2469         if (!UNIT_VTABLE(u)->show_status)
2470                 return;
2471
2472         if (!manager_get_show_status(u->manager))
2473                 return;
2474
2475         if (!manager_is_booting_or_shutting_down(u->manager))
2476                 return;
2477
2478         va_start(ap, format);
2479         status_vprintf(status, true, format, ap);
2480         va_end(ap);
2481 }
2482
2483 bool unit_need_daemon_reload(Unit *u) {
2484         assert(u);
2485
2486         if (u->fragment_path) {
2487                 struct stat st;
2488
2489                 zero(st);
2490                 if (stat(u->fragment_path, &st) < 0)
2491                         /* What, cannot access this anymore? */
2492                         return true;
2493
2494                 if (u->fragment_mtime > 0 &&
2495                     timespec_load(&st.st_mtim) != u->fragment_mtime)
2496                         return true;
2497         }
2498
2499         if (UNIT_VTABLE(u)->need_daemon_reload)
2500                 return UNIT_VTABLE(u)->need_daemon_reload(u);
2501
2502         return false;
2503 }
2504
2505 void unit_reset_failed(Unit *u) {
2506         assert(u);
2507
2508         if (UNIT_VTABLE(u)->reset_failed)
2509                 UNIT_VTABLE(u)->reset_failed(u);
2510 }
2511
2512 Unit *unit_following(Unit *u) {
2513         assert(u);
2514
2515         if (UNIT_VTABLE(u)->following)
2516                 return UNIT_VTABLE(u)->following(u);
2517
2518         return NULL;
2519 }
2520
2521 bool unit_pending_inactive(Unit *u) {
2522         assert(u);
2523
2524         /* Returns true if the unit is inactive or going down */
2525
2526         if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2527                 return true;
2528
2529         if (u->job && u->job->type == JOB_STOP)
2530                 return true;
2531
2532         return false;
2533 }
2534
2535 bool unit_pending_active(Unit *u) {
2536         assert(u);
2537
2538         /* Returns true if the unit is active or going up */
2539
2540         if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2541                 return true;
2542
2543         if (u->job &&
2544             (u->job->type == JOB_START ||
2545              u->job->type == JOB_RELOAD_OR_START ||
2546              u->job->type == JOB_RESTART))
2547                 return true;
2548
2549         return false;
2550 }
2551
2552 UnitType unit_name_to_type(const char *n) {
2553         UnitType t;
2554
2555         assert(n);
2556
2557         for (t = 0; t < _UNIT_TYPE_MAX; t++)
2558                 if (endswith(n, unit_vtable[t]->suffix))
2559                         return t;
2560
2561         return _UNIT_TYPE_INVALID;
2562 }
2563
2564 bool unit_name_is_valid(const char *n, bool template_ok) {
2565         UnitType t;
2566
2567         t = unit_name_to_type(n);
2568         if (t < 0 || t >= _UNIT_TYPE_MAX)
2569                 return false;
2570
2571         return unit_name_is_valid_no_type(n, template_ok);
2572 }
2573
2574 int unit_kill(Unit *u, KillWho w, KillMode m, int signo, DBusError *error) {
2575         assert(u);
2576         assert(w >= 0 && w < _KILL_WHO_MAX);
2577         assert(m >= 0 && m < _KILL_MODE_MAX);
2578         assert(signo > 0);
2579         assert(signo < _NSIG);
2580
2581         if (m == KILL_NONE)
2582                 return 0;
2583
2584         if (!UNIT_VTABLE(u)->kill)
2585                 return -ENOTSUP;
2586
2587         return UNIT_VTABLE(u)->kill(u, w, m, signo, error);
2588 }
2589
2590 int unit_following_set(Unit *u, Set **s) {
2591         assert(u);
2592         assert(s);
2593
2594         if (UNIT_VTABLE(u)->following_set)
2595                 return UNIT_VTABLE(u)->following_set(u, s);
2596
2597         *s = NULL;
2598         return 0;
2599 }
2600
2601 UnitFileState unit_get_unit_file_state(Unit *u) {
2602         assert(u);
2603
2604         if (u->unit_file_state < 0 && u->fragment_path)
2605                 u->unit_file_state = unit_file_get_state(
2606                                 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2607                                 NULL, file_name_from_path(u->fragment_path));
2608
2609         return u->unit_file_state;
2610 }
2611
2612 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2613         assert(ref);
2614         assert(u);
2615
2616         if (ref->unit)
2617                 unit_ref_unset(ref);
2618
2619         ref->unit = u;
2620         LIST_PREPEND(UnitRef, refs, u->refs, ref);
2621         return u;
2622 }
2623
2624 void unit_ref_unset(UnitRef *ref) {
2625         assert(ref);
2626
2627         if (!ref->unit)
2628                 return;
2629
2630         LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2631         ref->unit = NULL;
2632 }
2633
2634 static const char* const unit_load_state_table[_UNIT_LOAD_STATE_MAX] = {
2635         [UNIT_STUB] = "stub",
2636         [UNIT_LOADED] = "loaded",
2637         [UNIT_ERROR] = "error",
2638         [UNIT_MERGED] = "merged",
2639         [UNIT_MASKED] = "masked"
2640 };
2641
2642 DEFINE_STRING_TABLE_LOOKUP(unit_load_state, UnitLoadState);
2643
2644 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
2645         [UNIT_ACTIVE] = "active",
2646         [UNIT_RELOADING] = "reloading",
2647         [UNIT_INACTIVE] = "inactive",
2648         [UNIT_FAILED] = "failed",
2649         [UNIT_ACTIVATING] = "activating",
2650         [UNIT_DEACTIVATING] = "deactivating"
2651 };
2652
2653 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
2654
2655 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
2656         [UNIT_REQUIRES] = "Requires",
2657         [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
2658         [UNIT_WANTS] = "Wants",
2659         [UNIT_REQUISITE] = "Requisite",
2660         [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
2661         [UNIT_REQUIRED_BY] = "RequiredBy",
2662         [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
2663         [UNIT_BIND_TO] = "BindTo",
2664         [UNIT_WANTED_BY] = "WantedBy",
2665         [UNIT_CONFLICTS] = "Conflicts",
2666         [UNIT_CONFLICTED_BY] = "ConflictedBy",
2667         [UNIT_BOUND_BY] = "BoundBy",
2668         [UNIT_BEFORE] = "Before",
2669         [UNIT_AFTER] = "After",
2670         [UNIT_REFERENCES] = "References",
2671         [UNIT_REFERENCED_BY] = "ReferencedBy",
2672         [UNIT_ON_FAILURE] = "OnFailure",
2673         [UNIT_TRIGGERS] = "Triggers",
2674         [UNIT_TRIGGERED_BY] = "TriggeredBy",
2675         [UNIT_PROPAGATE_RELOAD_TO] = "PropagateReloadTo",
2676         [UNIT_PROPAGATE_RELOAD_FROM] = "PropagateReloadFrom"
2677 };
2678
2679 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);