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