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/>.
27 #include <sys/mount.h>
29 #include "systemd/sd-id128.h"
31 #include "machine-id-setup.h"
38 #include "path-util.h"
40 static int shorten_uuid(char destination[34], const char source[36]) {
43 for (i = 0, j = 0; i < 36 && j < 32; i++) {
46 t = unhexchar(source[i]);
50 destination[j++] = hexchar(t);
53 if (i == 36 && j == 32) {
54 destination[32] = '\n';
62 static int generate(char id[34], const char *root) {
67 const char *vm_id, *dbus_machine_id;
72 dbus_machine_id = "/var/lib/dbus/machine-id";
74 dbus_machine_id = strjoina(root, "/var/lib/dbus/machine-id");
76 /* First, try reading the D-Bus machine id, unless it is a symlink */
77 fd = open(dbus_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
79 r = loop_read_exact(fd, id, 33, false);
82 if (r >= 0 && id[32] == '\n') {
84 if (id128_is_valid(id)) {
88 log_info("Initializing machine ID from D-Bus machine ID.");
95 /* If that didn't work, see if we are running in a container,
96 * and a machine ID was passed in via $container_uuid the way
97 * libvirt/LXC does it */
98 r = detect_container(NULL);
100 _cleanup_free_ char *e = NULL;
102 r = getenv_for_pid(1, "container_uuid", &e);
104 if (strlen(e) >= 36) {
105 r = shorten_uuid(id, e);
107 log_info("Initializing machine ID from container UUID.");
114 /* If we are not running in a container, see if we are
115 * running in qemu/kvm and a machine ID was passed in
116 * via -uuid on the qemu/kvm command line */
118 r = detect_vm(&vm_id);
119 if (r > 0 && streq(vm_id, "kvm")) {
122 fd = open("/sys/class/dmi/id/product_uuid", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
124 r = loop_read_exact(fd, uuid, 36, false);
128 r = shorten_uuid(id, uuid);
130 log_info("Initializing machine ID from KVM UUID.");
139 /* If that didn't work, generate a random machine id */
140 r = sd_id128_randomize(&buf);
142 return log_error_errno(r, "Failed to open /dev/urandom: %m");
144 for (p = buf.bytes, q = id; p < buf.bytes + sizeof(buf); p++, q += 2) {
145 q[0] = hexchar(*p >> 4);
146 q[1] = hexchar(*p & 15);
152 log_info("Initializing machine ID from random generator.");
157 static int get_valid_machine_id(int fd, char id[34]) {
158 char id_to_validate[34];
163 if (loop_read_exact(fd, id_to_validate, 33, false) >= 0 &&
164 id_to_validate[32] == '\n') {
165 id_to_validate[32] = 0;
167 if (id128_is_valid(id_to_validate)) {
168 memcpy(id, id_to_validate, 32);
178 static int write_machine_id(int fd, char id[34]) {
181 lseek(fd, 0, SEEK_SET);
183 if (loop_write(fd, id, 33, false) == 0)
189 int machine_id_commit(const char *root) {
190 _cleanup_close_ int fd = -1, initial_mntns_fd = -1;
191 const char *etc_machine_id;
192 char id[34]; /* 32 + \n + \0 */
196 etc_machine_id = "/etc/machine-id";
200 x = strjoina(root, "/etc/machine-id");
201 etc_machine_id = path_kill_slashes(x);
204 r = path_is_mount_point(etc_machine_id, false);
206 return log_error_errno(r, "Failed to determine whether %s is a mount point: %m", etc_machine_id);
208 log_debug("%s is is not a mount point. Nothing to do.", etc_machine_id);
212 /* Read existing machine-id */
213 fd = open(etc_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY);
215 return log_error_errno(errno, "Cannot open %s: %m", etc_machine_id);
217 r = get_valid_machine_id(fd, id);
219 return log_error_errno(r, "We didn't find a valid machine ID in %s.", etc_machine_id);
221 r = is_fd_on_temporary_fs(fd);
223 return log_error_errno(r, "Failed to determine whether %s is on a temporary file system: %m", etc_machine_id);
225 log_error("%s is not on a temporary file system.", etc_machine_id);
231 /* Store current mount namespace */
232 r = namespace_open(0, NULL, &initial_mntns_fd, NULL, NULL);
234 return log_error_errno(r, "Can't fetch current mount namespace: %m");
236 /* Switch to a new mount namespace, isolate ourself and unmount etc_machine_id in our new namespace */
237 if (unshare(CLONE_NEWNS) < 0)
238 return log_error_errno(errno, "Failed to enter new namespace: %m");
240 if (mount(NULL, "/", NULL, MS_SLAVE | MS_REC, NULL) < 0)
241 return log_error_errno(errno, "Couldn't make-rslave / mountpoint in our private namespace: %m");
243 if (umount(etc_machine_id) < 0)
244 return log_error_errno(errno, "Failed to unmount transient %s file in our private namespace: %m", etc_machine_id);
246 /* Update a persistent version of etc_machine_id */
247 fd = open(etc_machine_id, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
249 return log_error_errno(errno, "Cannot open for writing %s. This is mandatory to get a persistent machine-id: %m", etc_machine_id);
251 r = write_machine_id(fd, id);
253 return log_error_errno(r, "Cannot write %s: %m", etc_machine_id);
257 /* Return to initial namespace and proceed a lazy tmpfs unmount */
258 r = namespace_enter(-1, initial_mntns_fd, -1, -1);
260 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);
262 if (umount2(etc_machine_id, MNT_DETACH) < 0)
263 return log_warning_errno(errno, "Failed to unmount transient %s file: %m.\nWe keep that mount until next reboot.", etc_machine_id);
268 int machine_id_setup(const char *root) {
269 const char *etc_machine_id, *run_machine_id;
270 _cleanup_close_ int fd = -1;
271 bool writable = true;
273 char id[34]; /* 32 + \n + \0 */
277 etc_machine_id = "/etc/machine-id";
278 run_machine_id = "/run/machine-id";
282 x = strjoina(root, "/etc/machine-id");
283 etc_machine_id = path_kill_slashes(x);
285 x = strjoina(root, "/run/machine-id");
286 run_machine_id = path_kill_slashes(x);
289 RUN_WITH_UMASK(0000) {
290 /* We create this 0444, to indicate that this isn't really
291 * something you should ever modify. Of course, since the file
292 * will be owned by root it doesn't matter much, but maybe
295 mkdir_parents(etc_machine_id, 0755);
296 fd = open(etc_machine_id, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
298 int old_errno = errno;
300 fd = open(etc_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY);
302 if (old_errno == EROFS && errno == ENOENT)
303 log_error("System cannot boot: Missing /etc/machine-id and /etc is mounted read-only.\n"
304 "Booting up is supported only when:\n"
305 "1) /etc/machine-id exists and is populated.\n"
306 "2) /etc/machine-id exists and is empty.\n"
307 "3) /etc/machine-id is missing and /etc is writable.\n");
309 log_error_errno(errno, "Cannot open %s: %m", etc_machine_id);
317 if (fstat(fd, &st) < 0)
318 return log_error_errno(errno, "fstat() failed: %m");
320 if (S_ISREG(st.st_mode) && get_valid_machine_id(fd, id) == 0)
323 /* Hmm, so, the id currently stored is not useful, then let's
326 r = generate(id, root);
330 if (S_ISREG(st.st_mode) && writable)
331 if (write_machine_id(fd, id) == 0)
336 /* Hmm, we couldn't write it? So let's write it to
337 * /run/machine-id as a replacement */
339 RUN_WITH_UMASK(0022) {
340 r = write_string_file(run_machine_id, id);
343 log_error_errno(r, "Cannot write %s: %m", run_machine_id);
344 unlink(run_machine_id);
348 /* And now, let's mount it over */
349 r = mount(run_machine_id, etc_machine_id, NULL, MS_BIND, NULL);
351 log_error_errno(errno, "Failed to mount %s: %m", etc_machine_id);
352 unlink_noerrno(run_machine_id);
356 log_info("Installed transient %s file.", etc_machine_id);
358 /* Mark the mount read-only */
359 if (mount(NULL, etc_machine_id, NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, NULL) < 0)
360 log_warning_errno(errno, "Failed to make transient %s read-only: %m", etc_machine_id);