src/core/unit.c

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