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