]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/machine/machined.c
shared: split out polkit stuff from bus-util.c → bus-polkit.c
[thirdparty/systemd.git] / src / machine / machined.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <errno.h>
4 #include <string.h>
5 #include <sys/stat.h>
6 #include <sys/types.h>
7 #include <unistd.h>
8
9 #include "sd-daemon.h"
10
11 #include "alloc-util.h"
12 #include "bus-error.h"
13 #include "bus-polkit.h"
14 #include "cgroup-util.h"
15 #include "dirent-util.h"
16 #include "fd-util.h"
17 #include "format-util.h"
18 #include "hostname-util.h"
19 #include "label.h"
20 #include "machine-image.h"
21 #include "machined.h"
22 #include "main-func.h"
23 #include "process-util.h"
24 #include "signal-util.h"
25 #include "special.h"
26
27 static Manager* manager_unref(Manager *m);
28 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_unref);
29
30 DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(machine_hash_ops, char, string_hash_func, string_compare_func, Machine, machine_free);
31
32 static int manager_new(Manager **ret) {
33 _cleanup_(manager_unrefp) Manager *m = NULL;
34 int r;
35
36 assert(ret);
37
38 m = new0(Manager, 1);
39 if (!m)
40 return -ENOMEM;
41
42 m->machines = hashmap_new(&machine_hash_ops);
43 m->machine_units = hashmap_new(&string_hash_ops);
44 m->machine_leaders = hashmap_new(NULL);
45
46 if (!m->machines || !m->machine_units || !m->machine_leaders)
47 return -ENOMEM;
48
49 r = sd_event_default(&m->event);
50 if (r < 0)
51 return r;
52
53 r = sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
54 if (r < 0)
55 return r;
56
57 r = sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
58 if (r < 0)
59 return r;
60
61 (void) sd_event_set_watchdog(m->event, true);
62
63 *ret = TAKE_PTR(m);
64 return 0;
65 }
66
67 static Manager* manager_unref(Manager *m) {
68 if (!m)
69 return NULL;
70
71 while (m->operations)
72 operation_free(m->operations);
73
74 assert(m->n_operations == 0);
75
76 hashmap_free(m->machines); /* This will free all machines, so that the machine_units/machine_leaders is empty */
77 hashmap_free(m->machine_units);
78 hashmap_free(m->machine_leaders);
79 hashmap_free(m->image_cache);
80
81 sd_event_source_unref(m->image_cache_defer_event);
82 sd_event_source_unref(m->nscd_cache_flush_event);
83
84 bus_verify_polkit_async_registry_free(m->polkit_registry);
85
86 sd_bus_flush_close_unref(m->bus);
87 sd_event_unref(m->event);
88
89 return mfree(m);
90 }
91
92 static int manager_add_host_machine(Manager *m) {
93 _cleanup_free_ char *rd = NULL, *unit = NULL;
94 sd_id128_t mid;
95 Machine *t;
96 int r;
97
98 if (m->host_machine)
99 return 0;
100
101 r = sd_id128_get_machine(&mid);
102 if (r < 0)
103 return log_error_errno(r, "Failed to get machine ID: %m");
104
105 rd = strdup("/");
106 if (!rd)
107 return log_oom();
108
109 unit = strdup(SPECIAL_ROOT_SLICE);
110 if (!unit)
111 return log_oom();
112
113 t = machine_new(m, MACHINE_HOST, ".host");
114 if (!t)
115 return log_oom();
116
117 t->leader = 1;
118 t->id = mid;
119
120 t->root_directory = TAKE_PTR(rd);
121 t->unit = TAKE_PTR(unit);
122
123 dual_timestamp_from_boottime_or_monotonic(&t->timestamp, 0);
124
125 m->host_machine = t;
126
127 return 0;
128 }
129
130 static int manager_enumerate_machines(Manager *m) {
131 _cleanup_closedir_ DIR *d = NULL;
132 struct dirent *de;
133 int r = 0;
134
135 assert(m);
136
137 r = manager_add_host_machine(m);
138 if (r < 0)
139 return r;
140
141 /* Read in machine data stored on disk */
142 d = opendir("/run/systemd/machines");
143 if (!d) {
144 if (errno == ENOENT)
145 return 0;
146
147 return log_error_errno(errno, "Failed to open /run/systemd/machines: %m");
148 }
149
150 FOREACH_DIRENT(de, d, return -errno) {
151 struct Machine *machine;
152 int k;
153
154 if (!dirent_is_file(de))
155 continue;
156
157 /* Ignore symlinks that map the unit name to the machine */
158 if (startswith(de->d_name, "unit:"))
159 continue;
160
161 if (!machine_name_is_valid(de->d_name))
162 continue;
163
164 k = manager_add_machine(m, de->d_name, &machine);
165 if (k < 0) {
166 r = log_error_errno(k, "Failed to add machine by file name %s: %m", de->d_name);
167 continue;
168 }
169
170 machine_add_to_gc_queue(machine);
171
172 k = machine_load(machine);
173 if (k < 0)
174 r = k;
175 }
176
177 return r;
178 }
179
180 static int manager_connect_bus(Manager *m) {
181 int r;
182
183 assert(m);
184 assert(!m->bus);
185
186 r = sd_bus_default_system(&m->bus);
187 if (r < 0)
188 return log_error_errno(r, "Failed to connect to system bus: %m");
189
190 r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/machine1", "org.freedesktop.machine1.Manager", manager_vtable, m);
191 if (r < 0)
192 return log_error_errno(r, "Failed to add manager object vtable: %m");
193
194 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/machine1/machine", "org.freedesktop.machine1.Machine", machine_vtable, machine_object_find, m);
195 if (r < 0)
196 return log_error_errno(r, "Failed to add machine object vtable: %m");
197
198 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/machine1/machine", machine_node_enumerator, m);
199 if (r < 0)
200 return log_error_errno(r, "Failed to add machine enumerator: %m");
201
202 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/machine1/image", "org.freedesktop.machine1.Image", image_vtable, image_object_find, m);
203 if (r < 0)
204 return log_error_errno(r, "Failed to add image object vtable: %m");
205
206 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/machine1/image", image_node_enumerator, m);
207 if (r < 0)
208 return log_error_errno(r, "Failed to add image enumerator: %m");
209
210 r = sd_bus_match_signal_async(
211 m->bus,
212 NULL,
213 "org.freedesktop.systemd1",
214 "/org/freedesktop/systemd1",
215 "org.freedesktop.systemd1.Manager",
216 "JobRemoved",
217 match_job_removed, NULL, m);
218 if (r < 0)
219 return log_error_errno(r, "Failed to add match for JobRemoved: %m");
220
221 r = sd_bus_match_signal_async(
222 m->bus,
223 NULL,
224 "org.freedesktop.systemd1",
225 "/org/freedesktop/systemd1",
226 "org.freedesktop.systemd1.Manager",
227 "UnitRemoved",
228 match_unit_removed, NULL, m);
229 if (r < 0)
230 return log_error_errno(r, "Failed to request match for UnitRemoved: %m");
231
232 r = sd_bus_match_signal_async(
233 m->bus,
234 NULL,
235 "org.freedesktop.systemd1",
236 NULL,
237 "org.freedesktop.DBus.Properties",
238 "PropertiesChanged",
239 match_properties_changed, NULL, m);
240 if (r < 0)
241 return log_error_errno(r, "Failed to request match for PropertiesChanged: %m");
242
243 r = sd_bus_match_signal_async(
244 m->bus,
245 NULL,
246 "org.freedesktop.systemd1",
247 "/org/freedesktop/systemd1",
248 "org.freedesktop.systemd1.Manager",
249 "Reloading",
250 match_reloading, NULL, m);
251 if (r < 0)
252 return log_error_errno(r, "Failed to request match for Reloading: %m");
253
254 r = sd_bus_call_method_async(
255 m->bus,
256 NULL,
257 "org.freedesktop.systemd1",
258 "/org/freedesktop/systemd1",
259 "org.freedesktop.systemd1.Manager",
260 "Subscribe",
261 NULL, NULL,
262 NULL);
263 if (r < 0)
264 return log_error_errno(r, "Failed to enable subscription: %m");
265
266 r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.machine1", 0, NULL, NULL);
267 if (r < 0)
268 return log_error_errno(r, "Failed to request name: %m");
269
270 r = sd_bus_attach_event(m->bus, m->event, 0);
271 if (r < 0)
272 return log_error_errno(r, "Failed to attach bus to event loop: %m");
273
274 return 0;
275 }
276
277 static void manager_gc(Manager *m, bool drop_not_started) {
278 Machine *machine;
279
280 assert(m);
281
282 while ((machine = m->machine_gc_queue)) {
283 LIST_REMOVE(gc_queue, m->machine_gc_queue, machine);
284 machine->in_gc_queue = false;
285
286 /* First, if we are not closing yet, initiate stopping */
287 if (machine_may_gc(machine, drop_not_started) &&
288 machine_get_state(machine) != MACHINE_CLOSING)
289 machine_stop(machine);
290
291 /* Now, the stop probably made this referenced
292 * again, but if it didn't, then it's time to let it
293 * go entirely. */
294 if (machine_may_gc(machine, drop_not_started)) {
295 machine_finalize(machine);
296 machine_free(machine);
297 }
298 }
299 }
300
301 static int manager_startup(Manager *m) {
302 Machine *machine;
303 Iterator i;
304 int r;
305
306 assert(m);
307
308 /* Connect to the bus */
309 r = manager_connect_bus(m);
310 if (r < 0)
311 return r;
312
313 /* Deserialize state */
314 manager_enumerate_machines(m);
315
316 /* Remove stale objects before we start them */
317 manager_gc(m, false);
318
319 /* And start everything */
320 HASHMAP_FOREACH(machine, m->machines, i)
321 machine_start(machine, NULL, NULL);
322
323 return 0;
324 }
325
326 static bool check_idle(void *userdata) {
327 Manager *m = userdata;
328
329 if (m->operations)
330 return false;
331
332 manager_gc(m, true);
333
334 return hashmap_isempty(m->machines);
335 }
336
337 static int manager_run(Manager *m) {
338 assert(m);
339
340 return bus_event_loop_with_idle(
341 m->event,
342 m->bus,
343 "org.freedesktop.machine1",
344 DEFAULT_EXIT_USEC,
345 check_idle, m);
346 }
347
348 static int run(int argc, char *argv[]) {
349 _cleanup_(manager_unrefp) Manager *m = NULL;
350 int r;
351
352 log_set_facility(LOG_AUTH);
353 log_setup_service();
354
355 umask(0022);
356
357 if (argc != 1) {
358 log_error("This program takes no arguments.");
359 return -EINVAL;
360 }
361
362 /* Always create the directories people can create inotify watches in. Note that some applications might check
363 * for the existence of /run/systemd/machines/ to determine whether machined is available, so please always
364 * make sure this check stays in. */
365 (void) mkdir_label("/run/systemd/machines", 0755);
366
367 assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, SIGTERM, SIGINT, -1) >= 0);
368
369 r = manager_new(&m);
370 if (r < 0)
371 return log_error_errno(r, "Failed to allocate manager object: %m");
372
373 r = manager_startup(m);
374 if (r < 0)
375 return log_error_errno(r, "Failed to fully start up daemon: %m");
376
377 log_debug("systemd-machined running as pid "PID_FMT, getpid_cached());
378 (void) sd_notify(false,
379 "READY=1\n"
380 "STATUS=Processing requests...");
381
382 r = manager_run(m);
383
384 log_debug("systemd-machined stopped as pid "PID_FMT, getpid_cached());
385 (void) sd_notify(false,
386 "STOPPING=1\n"
387 "STATUS=Shutting down...");
388
389 return r;
390 }
391
392 DEFINE_MAIN_FUNCTION(run);