1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
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.
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.
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/>.
28 #include <sys/mount.h>
30 #include "systemd/sd-id128.h"
32 #include "machine-id-setup.h"
39 #include "path-util.h"
41 static int shorten_uuid(char destination[34], const char source[36]) {
44 for (i = 0, j = 0; i < 36 && j < 32; i++) {
47 t = unhexchar(source[i]);
51 destination[j++] = hexchar(t);
54 if (i == 36 && j == 32) {
55 destination[32] = '\n';
63 static int generate(char id[34], const char *root) {
69 const char *vm_id, *dbus_machine_id;
74 dbus_machine_id = "/var/lib/dbus/machine-id";
76 dbus_machine_id = strappenda(root, "/var/lib/dbus/machine-id");
78 /* First, try reading the D-Bus machine id, unless it is a symlink */
79 fd = open(dbus_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
81 k = loop_read(fd, id, 33, false);
84 if (k == 33 && id[32] == '\n') {
87 if (id128_is_valid(id)) {
91 log_info("Initializing machine ID from D-Bus machine ID.");
98 /* If that didn't work, see if we are running in a container,
99 * and a machine ID was passed in via $container_uuid the way
100 * libvirt/LXC does it */
101 r = detect_container(NULL);
103 _cleanup_free_ char *e = NULL;
105 r = getenv_for_pid(1, "container_uuid", &e);
107 if (strlen(e) >= 36) {
108 r = shorten_uuid(id, e);
110 log_info("Initializing machine ID from container UUID.");
117 /* If we are not running in a container, see if we are
118 * running in qemu/kvm and a machine ID was passed in
119 * via -uuid on the qemu/kvm command line */
121 r = detect_vm(&vm_id);
122 if (r > 0 && streq(vm_id, "kvm")) {
125 fd = open("/sys/class/dmi/id/product_uuid", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
127 k = loop_read(fd, uuid, 36, false);
131 r = shorten_uuid(id, uuid);
133 log_info("Initializing machine ID from KVM UUID.");
142 /* If that didn't work, generate a random machine id */
143 r = sd_id128_randomize(&buf);
145 return log_error_errno(r, "Failed to open /dev/urandom: %m");
147 for (p = buf.bytes, q = id; p < buf.bytes + sizeof(buf); p++, q += 2) {
148 q[0] = hexchar(*p >> 4);
149 q[1] = hexchar(*p & 15);
155 log_info("Initializing machine ID from random generator.");
160 static int get_valid_machine_id(int fd, char id[34]) {
161 char id_to_validate[34];
166 if (loop_read(fd, id_to_validate, 33, false) == 33 && id_to_validate[32] == '\n') {
167 id_to_validate[32] = 0;
169 if (id128_is_valid(id_to_validate)) {
170 memcpy(id, id_to_validate, 32);
180 static int write_machine_id(int fd, char id[34]) {
183 lseek(fd, 0, SEEK_SET);
185 if (loop_write(fd, id, 33, false) == 33)
191 int machine_id_commit(const char *root) {
192 _cleanup_close_ int fd = -1, initial_mntns_fd = -1;
193 const char *etc_machine_id;
194 char id[34]; /* 32 + \n + \0 */
198 etc_machine_id = "/etc/machine-id";
202 x = strappenda(root, "/etc/machine-id");
203 etc_machine_id = path_kill_slashes(x);
206 r = path_is_mount_point(etc_machine_id, false);
208 return log_error_errno(r, "Failed to determine wether %s is a mount point: %m", etc_machine_id);
210 log_debug("%s is is not a mount point. Nothing to do.", etc_machine_id);
214 /* Read existing machine-id */
215 fd = open(etc_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY);
217 return log_error_errno(errno, "Cannot open %s: %m", etc_machine_id);
219 r = get_valid_machine_id(fd, id);
221 return log_error_errno(r, "We didn't find a valid machine ID in %s.", etc_machine_id);
223 r = is_fd_on_temporary_fs(fd);
225 return log_error_errno(r, "Failed to determine whether %s is on a temporary file system: %m", etc_machine_id);
227 log_error("%s is not on a temporary file system.", etc_machine_id);
233 /* Store current mount namespace */
234 r = namespace_open(0, NULL, &initial_mntns_fd, NULL, NULL);
236 return log_error_errno(r, "Can't fetch current mount namespace: %m");
238 /* Switch to a new mount namespace, isolate ourself and unmount etc_machine_id in our new namespace */
239 if (unshare(CLONE_NEWNS) < 0)
240 return log_error_errno(errno, "Failed to enter new namespace: %m");
242 if (mount(NULL, "/", NULL, MS_SLAVE | MS_REC, NULL) < 0)
243 return log_error_errno(errno, "Couldn't make-rslave / mountpoint in our private namespace: %m");
245 if (umount(etc_machine_id) < 0)
246 return log_error_errno(errno, "Failed to unmount transient %s file in our private namespace: %m", etc_machine_id);
248 /* Update a persistent version of etc_machine_id */
249 fd = open(etc_machine_id, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
251 return log_error_errno(errno, "Cannot open for writing %s. This is mandatory to get a persistent machine-id: %m", etc_machine_id);
253 r = write_machine_id(fd, id);
255 return log_error_errno(r, "Cannot write %s: %m", etc_machine_id);
259 /* Return to initial namespace and proceed a lazy tmpfs unmount */
260 r = namespace_enter(-1, initial_mntns_fd, -1, -1);
262 return log_warning_errno(r, "Failed to switch back to initial mount namespace: %m.\nWe'll keep transient %s file until next reboot.", etc_machine_id);
264 if (umount2(etc_machine_id, MNT_DETACH) < 0)
265 return log_warning_errno(errno, "Failed to unmount transient %s file: %m.\nWe keep that mount until next reboot.", etc_machine_id);
270 int machine_id_setup(const char *root) {
271 const char *etc_machine_id, *run_machine_id;
272 _cleanup_close_ int fd = -1;
273 bool writable = true;
275 char id[34]; /* 32 + \n + \0 */
279 etc_machine_id = "/etc/machine-id";
280 run_machine_id = "/run/machine-id";
284 x = strappenda(root, "/etc/machine-id");
285 etc_machine_id = path_kill_slashes(x);
287 x = strappenda(root, "/run/machine-id");
288 run_machine_id = path_kill_slashes(x);
291 RUN_WITH_UMASK(0000) {
292 /* We create this 0444, to indicate that this isn't really
293 * something you should ever modify. Of course, since the file
294 * will be owned by root it doesn't matter much, but maybe
297 mkdir_parents(etc_machine_id, 0755);
298 fd = open(etc_machine_id, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
300 int old_errno = errno;
302 fd = open(etc_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY);
304 if (old_errno == EROFS && errno == ENOENT)
305 log_error("System cannot boot: Missing /etc/machine-id and /etc is mounted read-only.\n"
306 "Booting up is supported only when:\n"
307 "1) /etc/machine-id exists and is populated.\n"
308 "2) /etc/machine-id exists and is empty.\n"
309 "3) /etc/machine-id is missing and /etc is writable.\n");
311 log_error_errno(errno, "Cannot open %s: %m", etc_machine_id);
319 if (fstat(fd, &st) < 0)
320 return log_error_errno(errno, "fstat() failed: %m");
322 if (S_ISREG(st.st_mode) && get_valid_machine_id(fd, id) == 0)
325 /* Hmm, so, the id currently stored is not useful, then let's
328 r = generate(id, root);
332 if (S_ISREG(st.st_mode) && writable) {
333 if (write_machine_id(fd, id) == 0)
339 /* Hmm, we couldn't write it? So let's write it to
340 * /run/machine-id as a replacement */
342 RUN_WITH_UMASK(0022) {
343 r = write_string_file(run_machine_id, id);
346 log_error_errno(r, "Cannot write %s: %m", run_machine_id);
347 unlink(run_machine_id);
351 /* And now, let's mount it over */
352 r = mount(run_machine_id, etc_machine_id, NULL, MS_BIND, NULL);
354 log_error_errno(errno, "Failed to mount %s: %m", etc_machine_id);
355 unlink_noerrno(run_machine_id);
359 log_info("Installed transient %s file.", etc_machine_id);
361 /* Mark the mount read-only */
362 if (mount(NULL, etc_machine_id, NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, NULL) < 0)
363 log_warning_errno(errno, "Failed to make transient %s read-only: %m", etc_machine_id);