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