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