chiark / gitweb /
unit: use weaker dependencies between mount and device units in --user mode
[elogind.git] / src / core / target.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
23 #include "unit.h"
24 #include "target.h"
25 #include "log.h"
26 #include "dbus-target.h"
27 #include "special.h"
28 #include "unit-name.h"
29
30 static const UnitActiveState state_translation_table[_TARGET_STATE_MAX] = {
31         [TARGET_DEAD] = UNIT_INACTIVE,
32         [TARGET_ACTIVE] = UNIT_ACTIVE
33 };
34
35 static void target_set_state(Target *t, TargetState state) {
36         TargetState old_state;
37         assert(t);
38
39         old_state = t->state;
40         t->state = state;
41
42         if (state != old_state)
43                 log_debug("%s changed %s -> %s",
44                           UNIT(t)->id,
45                           target_state_to_string(old_state),
46                           target_state_to_string(state));
47
48         unit_notify(UNIT(t), state_translation_table[old_state], state_translation_table[state], true);
49 }
50
51 static int target_add_default_dependencies(Target *t) {
52
53         static const UnitDependency deps[] = {
54                 UNIT_REQUIRES,
55                 UNIT_REQUIRES_OVERRIDABLE,
56                 UNIT_REQUISITE,
57                 UNIT_REQUISITE_OVERRIDABLE,
58                 UNIT_WANTS,
59                 UNIT_BINDS_TO,
60                 UNIT_PART_OF
61         };
62
63         Iterator i;
64         Unit *other;
65         int r;
66         unsigned k;
67
68         assert(t);
69
70         /* Imply ordering for requirement dependencies on target
71          * units. Note that when the user created a contradicting
72          * ordering manually we won't add anything in here to make
73          * sure we don't create a loop. */
74
75         for (k = 0; k < ELEMENTSOF(deps); k++)
76                 SET_FOREACH(other, UNIT(t)->dependencies[deps[k]], i) {
77                         r = unit_add_default_target_dependency(other, UNIT(t));
78                         if (r < 0)
79                                 return r;
80                 }
81
82         /* Make sure targets are unloaded on shutdown */
83         return unit_add_dependency_by_name(UNIT(t), UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
84 }
85
86 static int target_load(Unit *u) {
87         Target *t = TARGET(u);
88         int r;
89
90         assert(t);
91
92         r = unit_load_fragment_and_dropin(u);
93         if (r < 0)
94                 return r;
95
96         /* This is a new unit? Then let's add in some extras */
97         if (u->load_state == UNIT_LOADED && u->default_dependencies) {
98                 r = target_add_default_dependencies(t);
99                 if (r < 0)
100                         return r;
101         }
102
103         return 0;
104 }
105
106 static int target_coldplug(Unit *u) {
107         Target *t = TARGET(u);
108
109         assert(t);
110         assert(t->state == TARGET_DEAD);
111
112         if (t->deserialized_state != t->state)
113                 target_set_state(t, t->deserialized_state);
114
115         return 0;
116 }
117
118 static void target_dump(Unit *u, FILE *f, const char *prefix) {
119         Target *t = TARGET(u);
120
121         assert(t);
122         assert(f);
123
124         fprintf(f,
125                 "%sTarget State: %s\n",
126                 prefix, target_state_to_string(t->state));
127 }
128
129 static int target_start(Unit *u) {
130         Target *t = TARGET(u);
131
132         assert(t);
133         assert(t->state == TARGET_DEAD);
134
135         target_set_state(t, TARGET_ACTIVE);
136         return 1;
137 }
138
139 static int target_stop(Unit *u) {
140         Target *t = TARGET(u);
141
142         assert(t);
143         assert(t->state == TARGET_ACTIVE);
144
145         target_set_state(t, TARGET_DEAD);
146         return 1;
147 }
148
149 static int target_serialize(Unit *u, FILE *f, FDSet *fds) {
150         Target *s = TARGET(u);
151
152         assert(s);
153         assert(f);
154         assert(fds);
155
156         unit_serialize_item(u, f, "state", target_state_to_string(s->state));
157         return 0;
158 }
159
160 static int target_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
161         Target *s = TARGET(u);
162
163         assert(u);
164         assert(key);
165         assert(value);
166         assert(fds);
167
168         if (streq(key, "state")) {
169                 TargetState state;
170
171                 state = target_state_from_string(value);
172                 if (state < 0)
173                         log_debug("Failed to parse state value %s", value);
174                 else
175                         s->deserialized_state = state;
176
177         } else
178                 log_debug("Unknown serialization key '%s'", key);
179
180         return 0;
181 }
182
183 _pure_ static UnitActiveState target_active_state(Unit *u) {
184         assert(u);
185
186         return state_translation_table[TARGET(u)->state];
187 }
188
189 _pure_ static const char *target_sub_state_to_string(Unit *u) {
190         assert(u);
191
192         return target_state_to_string(TARGET(u)->state);
193 }
194
195 static const char* const target_state_table[_TARGET_STATE_MAX] = {
196         [TARGET_DEAD] = "dead",
197         [TARGET_ACTIVE] = "active"
198 };
199
200 DEFINE_STRING_TABLE_LOOKUP(target_state, TargetState);
201
202 const UnitVTable target_vtable = {
203         .object_size = sizeof(Target),
204
205         .sections =
206                 "Unit\0"
207                 "Target\0"
208                 "Install\0",
209
210         .load = target_load,
211         .coldplug = target_coldplug,
212
213         .dump = target_dump,
214
215         .start = target_start,
216         .stop = target_stop,
217
218         .serialize = target_serialize,
219         .deserialize_item = target_deserialize_item,
220
221         .active_state = target_active_state,
222         .sub_state_to_string = target_sub_state_to_string,
223
224         .bus_interface = "org.freedesktop.systemd1.Target",
225         .bus_vtable = bus_target_vtable,
226
227         .status_message_formats = {
228                 .finished_start_job = {
229                         [JOB_DONE]       = "Reached target %s.",
230                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
231                 },
232                 .finished_stop_job = {
233                         [JOB_DONE]       = "Stopped target %s.",
234                 },
235         },
236 };