[thirdparty/systemd.git] / src / login / logind-machine.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <string.h>
#include <unistd.h>
#include <errno.h>

#include "logind-machine.h"
#include "util.h"
#include "mkdir.h"
#include "cgroup-util.h"
#include "hashmap.h"
#include "strv.h"
#include "fileio.h"
#include "special.h"
#include <systemd/sd-messages.h>

Machine* machine_new(Manager *manager, const char *name) {
        Machine *m;

        assert(manager);
        assert(name);

        m = new0(Machine, 1);
        if (!m)
                return NULL;

        m->name = strdup(name);
        if (!m->name)
                goto fail;

        m->state_file = strappend("/run/systemd/machines/", m->name);
        if (!m->state_file)
                goto fail;

        if (hashmap_put(manager->machines, m->name, m) < 0)
                goto fail;

        m->class = _MACHINE_CLASS_INVALID;
        m->manager = manager;

        return m;

fail:
        free(m->state_file);
        free(m->name);
        free(m);

        return NULL;
}

void machine_free(Machine *m) {
        assert(m);

        if (m->in_gc_queue)
                LIST_REMOVE(Machine, gc_queue, m->manager->machine_gc_queue, m);

        if (m->cgroup_path) {
                hashmap_remove(m->manager->machine_cgroups, m->cgroup_path);
                free(m->cgroup_path);
        }

        hashmap_remove(m->manager->machines, m->name);

        free(m->name);
        free(m->state_file);
        free(m->service);
        free(m->slice);
        free(m->root_directory);
        free(m);
}

int machine_save(Machine *m) {
        _cleanup_free_ char *temp_path = NULL;
        _cleanup_fclose_ FILE *f = NULL;
        int r;

        assert(m);
        assert(m->state_file);

        if (!m->started)
                return 0;

        r = mkdir_safe_label("/run/systemd/machines", 0755, 0, 0);
        if (r < 0)
                goto finish;

        r = fopen_temporary(m->state_file, &f, &temp_path);
        if (r < 0)
                goto finish;

        fchmod(fileno(f), 0644);

        fprintf(f,
                "# This is private data. Do not parse.\n"
                "NAME=%s\n",
                m->name);

        if (m->cgroup_path)
                fprintf(f, "CGROUP=%s\n", m->cgroup_path);

        if (m->service)
                fprintf(f, "SERVICE=%s\n", m->service);

        if (m->slice)
                fprintf(f, "SLICE=%s\n", m->slice);

        if (m->root_directory)
                fprintf(f, "ROOT=%s\n", m->root_directory);

        if (!sd_id128_equal(m->id, SD_ID128_NULL))
                fprintf(f, "ID=" SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(m->id));

        if (m->leader != 0)
                fprintf(f, "LEADER=%lu\n", (unsigned long) m->leader);

        if (m->class != _MACHINE_CLASS_INVALID)
                fprintf(f, "CLASS=%s\n", machine_class_to_string(m->class));

        if (dual_timestamp_is_set(&m->timestamp))
                fprintf(f,
                        "REALTIME=%llu\n"
                        "MONOTONIC=%llu\n",
                        (unsigned long long) m->timestamp.realtime,
                        (unsigned long long) m->timestamp.monotonic);

        fflush(f);

        if (ferror(f) || rename(temp_path, m->state_file) < 0) {
                r = -errno;
                unlink(m->state_file);
                unlink(temp_path);
        }

finish:
        if (r < 0)
                log_error("Failed to save machine data for %s: %s", m->name, strerror(-r));

        return r;
}

int machine_load(Machine *m) {
        _cleanup_free_ char *realtime = NULL, *monotonic = NULL, *id = NULL, *leader = NULL, *class = NULL;
        int r;

        assert(m);

        r = parse_env_file(m->state_file, NEWLINE,
                           "CGROUP",    &m->cgroup_path,
                           "SERVICE",   &m->service,
                           "SLICE",     &m->slice,
                           "ROOT",      &m->root_directory,
                           "ID",        &id,
                           "LEADER",    &leader,
                           "CLASS",     &class,
                           "REALTIME",  &realtime,
                           "MONOTONIC", &monotonic,
                           NULL);
        if (r < 0) {
                if (r == -ENOENT)
                        return 0;

                log_error("Failed to read %s: %s", m->state_file, strerror(-r));
                return r;
        }

        if (id)
                sd_id128_from_string(id, &m->id);

        if (leader)
                parse_pid(leader, &m->leader);

        if (class) {
                MachineClass c;

                c = machine_class_from_string(class);
                if (c >= 0)
                        m->class = c;
        }

        if (realtime) {
                unsigned long long l;
                if (sscanf(realtime, "%llu", &l) > 0)
                        m->timestamp.realtime = l;
        }

        if (monotonic) {
                unsigned long long l;
                if (sscanf(monotonic, "%llu", &l) > 0)
                        m->timestamp.monotonic = l;
        }

        return r;
}

static int machine_create_one_group(Machine *m, const char *controller, const char *path) {
        int r;

        assert(m);
        assert(path);

        if (m->leader > 0)
                r = cg_create_and_attach(controller, path, m->leader);
        else
                r = -EINVAL;

        if (r < 0) {
                r = cg_create(controller, path);
                if (r < 0)
                        return r;
        }

        return 0;
}

static int machine_create_cgroup(Machine *m) {
        char **k;
        int r;

        assert(m);

        if (!m->slice) {
                m->slice = strdup(SPECIAL_MACHINE_SLICE);
                if (!m->slice)
                        return log_oom();
        }

        if (!m->cgroup_path) {
                _cleanup_free_ char *escaped = NULL, *slice = NULL;
                char *name;

                name = strappenda(m->name, ".machine");

                escaped = cg_escape(name);
                if (!escaped)
                        return log_oom();

                r = cg_slice_to_path(m->slice, &slice);
                if (r < 0)
                        return r;

                m->cgroup_path = strjoin(m->manager->cgroup_root, "/", slice, "/", escaped, NULL);
                if (!m->cgroup_path)
                        return log_oom();
        }

        r = machine_create_one_group(m, SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path);
        if (r < 0) {
                log_error("Failed to create cgroup "SYSTEMD_CGROUP_CONTROLLER":%s: %s", m->cgroup_path, strerror(-r));
                return r;
        }

        STRV_FOREACH(k, m->manager->controllers) {

                if (strv_contains(m->manager->reset_controllers, *k))
                        continue;

                r = machine_create_one_group(m, *k, m->cgroup_path);
                if (r < 0)
                        log_warning("Failed to create cgroup %s:%s: %s", *k, m->cgroup_path, strerror(-r));
        }

        if (m->leader > 0) {
                STRV_FOREACH(k, m->manager->reset_controllers) {
                        r = cg_attach(*k, "/", m->leader);
                        if (r < 0)
                                log_warning("Failed to reset controller %s: %s", *k, strerror(-r));
                }
        }

        r = hashmap_put(m->manager->machine_cgroups, m->cgroup_path, m);
        if (r < 0)
                log_warning("Failed to create mapping between cgroup and machine");

        return 0;
}

int machine_start(Machine *m) {
        int r;

        assert(m);

        if (m->started)
                return 0;

        log_struct(LOG_INFO,
                   MESSAGE_ID(SD_MESSAGE_MACHINE_START),
                   "NAME=%s", m->name,
                   "LEADER=%lu", (unsigned long) m->leader,
                   "MESSAGE=New machine %s.", m->name,
                   NULL);

        /* Create cgroup */
        r = machine_create_cgroup(m);
        if (r < 0)
                return r;

        if (!dual_timestamp_is_set(&m->timestamp))
                dual_timestamp_get(&m->timestamp);

        m->started = true;

        /* Save new machine data */
        machine_save(m);

        machine_send_signal(m, true);

        return 0;
}

static int machine_terminate_cgroup(Machine *m) {
        int r;
        char **k;

        assert(m);

        if (!m->cgroup_path)
                return 0;

        cg_trim(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, false);

        r = cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, true);
        if (r < 0)
                log_error("Failed to kill machine cgroup: %s", strerror(-r));

        STRV_FOREACH(k, m->manager->controllers)
                cg_trim(*k, m->cgroup_path, true);

        hashmap_remove(m->manager->machine_cgroups, m->cgroup_path);

        free(m->cgroup_path);
        m->cgroup_path = NULL;

        return r;
}

int machine_stop(Machine *m) {
        int r = 0, k;
        assert(m);

        if (m->started)
                log_struct(LOG_INFO,
                           MESSAGE_ID(SD_MESSAGE_MACHINE_STOP),
                           "NAME=%s", m->name,
                           "LEADER=%lu", (unsigned long) m->leader,
                           "MESSAGE=Machine %s terminated.", m->name,
                           NULL);

        /* Kill cgroup */
        k = machine_terminate_cgroup(m);
        if (k < 0)
                r = k;

        unlink(m->state_file);
        machine_add_to_gc_queue(m);

        if (m->started)
                machine_send_signal(m, false);

        m->started = false;

        return r;
}

int machine_check_gc(Machine *m, bool drop_not_started) {
        int r;

        assert(m);

        if (drop_not_started && !m->started)
                return 0;

        if (m->cgroup_path) {
                r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, false);
                if (r < 0)
                        return r;

                if (r <= 0)
                        return 1;
        }

        return 0;
}

void machine_add_to_gc_queue(Machine *m) {
        assert(m);

        if (m->in_gc_queue)
                return;

        LIST_PREPEND(Machine, gc_queue, m->manager->machine_gc_queue, m);
        m->in_gc_queue = true;
}

int machine_kill(Machine *m, KillWho who, int signo) {
        _cleanup_set_free_ Set *pid_set = NULL;
        int r = 0;

        assert(m);

        if (!m->cgroup_path)
                return -ESRCH;

        if (m->leader <= 0 && who == KILL_LEADER)
                return -ESRCH;

        if (m->leader > 0)
                if (kill(m->leader, signo) < 0)
                        r = -errno;

        if (who == KILL_ALL) {
                int q;

                pid_set = set_new(trivial_hash_func, trivial_compare_func);
                if (!pid_set)
                        return log_oom();

                if (m->leader > 0) {
                        q = set_put(pid_set, LONG_TO_PTR(m->leader));
                        if (q < 0)
                                r = q;
                }

                q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, signo, false, true, false, pid_set);
                if (q < 0 && (q != -EAGAIN && q != -ESRCH && q != -ENOENT))
                        r = q;
        }

        return r;
}

static const char* const machine_class_table[_MACHINE_CLASS_MAX] = {
        [MACHINE_CONTAINER] = "container",
        [MACHINE_VM] = "vm"
};

DEFINE_STRING_TABLE_LOOKUP(machine_class, MachineClass);
Commit	Line	Data
9444b1f2 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2011 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <string.h>
	23	#include <unistd.h>
	24	#include <errno.h>
	25
	26	#include "logind-machine.h"
	27	#include "util.h"
	28	#include "mkdir.h"
	29	#include "cgroup-util.h"
	30	#include "hashmap.h"
	31	#include "strv.h"
	32	#include "fileio.h"
	33	#include "special.h"
	34	#include <systemd/sd-messages.h>
	35
	36	Machine* machine_new(Manager manager, const char name) {
	37	Machine *m;
	38
	39	assert(manager);
	40	assert(name);
	41
	42	m = new0(Machine, 1);
	43	if (!m)
	44	return NULL;
	45
	46	m->name = strdup(name);
	47	if (!m->name)
	48	goto fail;
	49
	50	m->state_file = strappend("/run/systemd/machines/", m->name);
	51	if (!m->state_file)
	52	goto fail;
	53
	54	if (hashmap_put(manager->machines, m->name, m) < 0)
	55	goto fail;
	56
	57	m->class = _MACHINE_CLASS_INVALID;
	58	m->manager = manager;
	59
	60	return m;
	61
	62	fail:
	63	free(m->state_file);
	64	free(m->name);
65	free(m);
66
67	return NULL;
68	}
69
70	void machine_free(Machine *m) {
71	assert(m);
72
73	if (m->in_gc_queue)
74	LIST_REMOVE(Machine, gc_queue, m->manager->machine_gc_queue, m);
75
76	if (m->cgroup_path) {
77	hashmap_remove(m->manager->machine_cgroups, m->cgroup_path);
78	free(m->cgroup_path);
79	}
80
81	hashmap_remove(m->manager->machines, m->name);
82
83	free(m->name);
84	free(m->state_file);
85	free(m->service);
86	free(m->slice);
87	free(m->root_directory);
88	free(m);
89	}
90
91	int machine_save(Machine *m) {
92	_cleanup_free_ char *temp_path = NULL;
93	_cleanup_fclose_ FILE *f = NULL;
94	int r;
95
96	assert(m);
97	assert(m->state_file);
98
99	if (!m->started)
100	return 0;
101
102	r = mkdir_safe_label("/run/systemd/machines", 0755, 0, 0);
103	if (r < 0)
104	goto finish;
105
106	r = fopen_temporary(m->state_file, &f, &temp_path);
107	if (r < 0)
108	goto finish;
109
110	fchmod(fileno(f), 0644);
111
112	fprintf(f,
113	"# This is private data. Do not parse.\n"
114	"NAME=%s\n",
115	m->name);
116
117	if (m->cgroup_path)
118	fprintf(f, "CGROUP=%s\n", m->cgroup_path);
119
120	if (m->service)
121	fprintf(f, "SERVICE=%s\n", m->service);
122
123	if (m->slice)
124	fprintf(f, "SLICE=%s\n", m->slice);
125
126	if (m->root_directory)
127	fprintf(f, "ROOT=%s\n", m->root_directory);
128
129	if (!sd_id128_equal(m->id, SD_ID128_NULL))
130	fprintf(f, "ID=" SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(m->id));
131
132	if (m->leader != 0)
133	fprintf(f, "LEADER=%lu\n", (unsigned long) m->leader);
134
135	if (m->class != _MACHINE_CLASS_INVALID)
136	fprintf(f, "CLASS=%s\n", machine_class_to_string(m->class));
137
138	if (dual_timestamp_is_set(&m->timestamp))
139	fprintf(f,
140	"REALTIME=%llu\n"
141	"MONOTONIC=%llu\n",
142	(unsigned long long) m->timestamp.realtime,
143	(unsigned long long) m->timestamp.monotonic);
144
145	fflush(f);
146
147	if (ferror(f) \|\| rename(temp_path, m->state_file) < 0) {
148	r = -errno;
149	unlink(m->state_file);
150	unlink(temp_path);
151	}
152
153	finish:
154	if (r < 0)
155	log_error("Failed to save machine data for %s: %s", m->name, strerror(-r));
156
157	return r;
158	}
159
160	int machine_load(Machine *m) {
161	_cleanup_free_ char realtime = NULL, monotonic = NULL, id = NULL, leader = NULL, *class = NULL;
162	int r;
163
164	assert(m);
165
166	r = parse_env_file(m->state_file, NEWLINE,
167	"CGROUP", &m->cgroup_path,
168	"SERVICE", &m->service,
169	"SLICE", &m->slice,
170	"ROOT", &m->root_directory,
171	"ID", &id,
172	"LEADER", &leader,
173	"CLASS", &class,
174	"REALTIME", &realtime,
175	"MONOTONIC", &monotonic,
176	NULL);
177	if (r < 0) {
178	if (r == -ENOENT)
179	return 0;
180
181	log_error("Failed to read %s: %s", m->state_file, strerror(-r));
182	return r;
183	}
184
185	if (id)
186	sd_id128_from_string(id, &m->id);
187
188	if (leader)
189	parse_pid(leader, &m->leader);
190
191	if (class) {
192	MachineClass c;
193
194	c = machine_class_from_string(class);
195	if (c >= 0)
196	m->class = c;
197	}
198
199	if (realtime) {
200	unsigned long long l;
201	if (sscanf(realtime, "%llu", &l) > 0)
202	m->timestamp.realtime = l;
203	}
204
205	if (monotonic) {
206	unsigned long long l;
207	if (sscanf(monotonic, "%llu", &l) > 0)
208	m->timestamp.monotonic = l;
209	}
210
211	return r;
212	}
213
214	static int machine_create_one_group(Machine m, const char controller, const char *path) {
215	int r;
216
217	assert(m);
218	assert(path);
219
220	if (m->leader > 0)
221	r = cg_create_and_attach(controller, path, m->leader);
222	else
223	r = -EINVAL;
224
225	if (r < 0) {
4ad49000	226	r = cg_create(controller, path);
9444b1f2 LP	227	if (r < 0)
	228	return r;
	229	}
	230
	231	return 0;
	232	}
	233
	234	static int machine_create_cgroup(Machine *m) {
	235	char **k;
	236	int r;
	237
	238	assert(m);
	239
	240	if (!m->slice) {
	241	m->slice = strdup(SPECIAL_MACHINE_SLICE);
	242	if (!m->slice)
	243	return log_oom();
	244	}
	245
	246	if (!m->cgroup_path) {
	247	_cleanup_free_ char escaped = NULL, slice = NULL;
	248	char *name;
	249
	250	name = strappenda(m->name, ".machine");
	251
	252	escaped = cg_escape(name);
	253	if (!escaped)
	254	return log_oom();
	255
	256	r = cg_slice_to_path(m->slice, &slice);
	257	if (r < 0)
	258	return r;
	259
	260	m->cgroup_path = strjoin(m->manager->cgroup_root, "/", slice, "/", escaped, NULL);
	261	if (!m->cgroup_path)
	262	return log_oom();
	263	}
	264
	265	r = machine_create_one_group(m, SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path);
	266	if (r < 0) {
	267	log_error("Failed to create cgroup "SYSTEMD_CGROUP_CONTROLLER":%s: %s", m->cgroup_path, strerror(-r));
	268	return r;
	269	}
	270
	271	STRV_FOREACH(k, m->manager->controllers) {
	272
	273	if (strv_contains(m->manager->reset_controllers, *k))
	274	continue;
	275
	276	r = machine_create_one_group(m, *k, m->cgroup_path);
	277	if (r < 0)
	278	log_warning("Failed to create cgroup %s:%s: %s", *k, m->cgroup_path, strerror(-r));
	279	}
	280
	281	if (m->leader > 0) {
	282	STRV_FOREACH(k, m->manager->reset_controllers) {
	283	r = cg_attach(*k, "/", m->leader);
	284	if (r < 0)
	285	log_warning("Failed to reset controller %s: %s", *k, strerror(-r));
	286	}
	287	}
	288
	289	r = hashmap_put(m->manager->machine_cgroups, m->cgroup_path, m);
	290	if (r < 0)
291	log_warning("Failed to create mapping between cgroup and machine");
292
293	return 0;
294	}
295
296	int machine_start(Machine *m) {
297	int r;
298
299	assert(m);
300
301	if (m->started)
302	return 0;
303
304	log_struct(LOG_INFO,
305	MESSAGE_ID(SD_MESSAGE_MACHINE_START),
306	"NAME=%s", m->name,
307	"LEADER=%lu", (unsigned long) m->leader,
308	"MESSAGE=New machine %s.", m->name,
309	NULL);
310
311	/* Create cgroup */
312	r = machine_create_cgroup(m);
313	if (r < 0)
314	return r;
315
316	if (!dual_timestamp_is_set(&m->timestamp))
317	dual_timestamp_get(&m->timestamp);
318
319	m->started = true;
320
321	/* Save new machine data */
322	machine_save(m);
323
324	machine_send_signal(m, true);
325
326	return 0;
327	}
328
329	static int machine_terminate_cgroup(Machine *m) {
330	int r;
331	char **k;
332
333	assert(m);
334
335	if (!m->cgroup_path)
336	return 0;
337
338	cg_trim(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, false);
339
340	r = cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, true);
341	if (r < 0)
342	log_error("Failed to kill machine cgroup: %s", strerror(-r));
343
344	STRV_FOREACH(k, m->manager->controllers)
345	cg_trim(*k, m->cgroup_path, true);
346
347	hashmap_remove(m->manager->machine_cgroups, m->cgroup_path);
348
349	free(m->cgroup_path);
350	m->cgroup_path = NULL;
351
352	return r;
353	}
354
355	int machine_stop(Machine *m) {
356	int r = 0, k;
357	assert(m);
358
359	if (m->started)
360	log_struct(LOG_INFO,
361	MESSAGE_ID(SD_MESSAGE_MACHINE_STOP),
362	"NAME=%s", m->name,
363	"LEADER=%lu", (unsigned long) m->leader,
364	"MESSAGE=Machine %s terminated.", m->name,
365	NULL);
366
367	/* Kill cgroup */
368	k = machine_terminate_cgroup(m);
369	if (k < 0)
370	r = k;
371
372	unlink(m->state_file);
373	machine_add_to_gc_queue(m);
374
375	if (m->started)
376	machine_send_signal(m, false);
377
378	m->started = false;
379
380	return r;
381	}
382
383	int machine_check_gc(Machine *m, bool drop_not_started) {
384	int r;
385
386	assert(m);
387
388	if (drop_not_started && !m->started)
389	return 0;
390
391	if (m->cgroup_path) {
392	r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, false);
393	if (r < 0)
394	return r;
395
396	if (r <= 0)
397	return 1;
398	}
399
400	return 0;
401	}
402
403	void machine_add_to_gc_queue(Machine *m) {
404	assert(m);
405
406	if (m->in_gc_queue)
407	return;
408
409	LIST_PREPEND(Machine, gc_queue, m->manager->machine_gc_queue, m);
410	m->in_gc_queue = true;
411	}
412
413	int machine_kill(Machine *m, KillWho who, int signo) {
414	_cleanup_set_free_ Set *pid_set = NULL;
415	int r = 0;
416
417	assert(m);
418
419	if (!m->cgroup_path)
420	return -ESRCH;
421
422	if (m->leader <= 0 && who == KILL_LEADER)
423	return -ESRCH;
424
425	if (m->leader > 0)
426	if (kill(m->leader, signo) < 0)
427	r = -errno;
428
429	if (who == KILL_ALL) {
430	int q;
431
432	pid_set = set_new(trivial_hash_func, trivial_compare_func);
433	if (!pid_set)
434	return log_oom();
435
436	if (m->leader > 0) {
437	q = set_put(pid_set, LONG_TO_PTR(m->leader));
438	if (q < 0)
439	r = q;
440	}
441
442	q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, signo, false, true, false, pid_set);
443	if (q < 0 && (q != -EAGAIN && q != -ESRCH && q != -ENOENT))
444	r = q;
445	}
446
447	return r;
448	}
449
450	static const char* const machine_class_table[_MACHINE_CLASS_MAX] = {
451	[MACHINE_CONTAINER] = "container",
452	[MACHINE_VM] = "vm"
453	};
454
455	DEFINE_STRING_TABLE_LOOKUP(machine_class, MachineClass);