src/core/machine-id-setup.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 #include <unistd.h>
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <string.h>
  26 #include <fcntl.h>
  27 #include <sys/mount.h>
  28
  29 #include "systemd/sd-id128.h"
  30
  31 #include "machine-id-setup.h"
  32 #include "macro.h"
  33 #include "util.h"
  34 #include "mkdir.h"
  35 #include "log.h"
  36 #include "virt.h"
  37 #include "fileio.h"
  38 #include "path-util.h"
  39
  40 static int shorten_uuid(char destination[34], const char source[36]) {
  41         unsigned i, j;
  42
  43         for (i = 0, j = 0; i < 36 && j < 32; i++) {
  44                 int t;
  45
  46                 t = unhexchar(source[i]);
  47                 if (t < 0)
  48                         continue;
  49
  50                 destination[j++] = hexchar(t);
  51         }
  52
  53         if (i == 36 && j == 32) {
  54                 destination[32] = '\n';
  55                 destination[33] = 0;
  56                 return 0;
  57         }
  58
  59         return -EINVAL;
  60 }
  61
  62 static int generate(char id[34], const char *root) {
  63         int fd, r;
  64         unsigned char *p;
  65         sd_id128_t buf;
  66         char  *q;
  67         ssize_t k;
  68         const char *vm_id, *dbus_machine_id;
  69
  70         assert(id);
  71
  72         if (isempty(root))
  73                 dbus_machine_id = "/var/lib/dbus/machine-id";
  74         else
  75                 dbus_machine_id = strjoina(root, "/var/lib/dbus/machine-id");
  76
  77         /* First, try reading the D-Bus machine id, unless it is a symlink */
  78         fd = open(dbus_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
  79         if (fd >= 0) {
  80                 k = loop_read(fd, id, 33, false);
  81                 safe_close(fd);
  82
  83                 if (k == 33 && id[32] == '\n') {
  84
  85                         id[32] = 0;
  86                         if (id128_is_valid(id)) {
  87                                 id[32] = '\n';
  88                                 id[33] = 0;
  89
  90                                 log_info("Initializing machine ID from D-Bus machine ID.");
  91                                 return 0;
  92                         }
  93                 }
  94         }
  95
  96         if (isempty(root)) {
  97                 /* If that didn't work, see if we are running in a container,
  98                  * and a machine ID was passed in via $container_uuid the way
  99                  * libvirt/LXC does it */
 100                 r = detect_container(NULL);
 101                 if (r > 0) {
 102                         _cleanup_free_ char *e = NULL;
 103
 104                         r = getenv_for_pid(1, "container_uuid", &e);
 105                         if (r > 0) {
 106                                 if (strlen(e) >= 36) {
 107                                         r = shorten_uuid(id, e);
 108                                         if (r >= 0) {
 109                                                 log_info("Initializing machine ID from container UUID.");
 110                                                 return 0;
 111                                         }
 112                                 }
 113                         }
 114
 115                 } else {
 116                         /* If we are not running in a container, see if we are
 117                          * running in qemu/kvm and a machine ID was passed in
 118                          * via -uuid on the qemu/kvm command line */
 119
 120                         r = detect_vm(&vm_id);
 121                         if (r > 0 && streq(vm_id, "kvm")) {
 122                                 char uuid[37];
 123
 124                                 fd = open("/sys/class/dmi/id/product_uuid", O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
 125                                 if (fd >= 0) {
 126                                         k = loop_read(fd, uuid, 36, false);
 127                                         safe_close(fd);
 128
 129                                         if (k >= 36) {
 130                                                 r = shorten_uuid(id, uuid);
 131                                                 if (r >= 0) {
 132                                                         log_info("Initializing machine ID from KVM UUID.");
 133                                                         return 0;
 134                                                 }
 135                                         }
 136                                 }
 137                         }
 138                 }
 139         }
 140
 141         /* If that didn't work, generate a random machine id */
 142         r = sd_id128_randomize(&buf);
 143         if (r < 0)
 144                 return log_error_errno(r, "Failed to open /dev/urandom: %m");
 145
 146         for (p = buf.bytes, q = id; p < buf.bytes + sizeof(buf); p++, q += 2) {
 147                 q[0] = hexchar(*p >> 4);
 148                 q[1] = hexchar(*p & 15);
 149         }
 150
 151         id[32] = '\n';
 152         id[33] = 0;
 153
 154         log_info("Initializing machine ID from random generator.");
 155
 156         return 0;
 157 }
 158
 159 static int get_valid_machine_id(int fd, char id[34]) {
 160         char id_to_validate[34];
 161
 162         assert(fd >= 0);
 163         assert(id);
 164
 165         if (loop_read(fd, id_to_validate, 33, false) == 33 && id_to_validate[32] == '\n') {
 166                 id_to_validate[32] = 0;
 167
 168                 if (id128_is_valid(id_to_validate)) {
 169                         memcpy(id, id_to_validate, 32);
 170                         id[32] = '\n';
 171                         id[33] = 0;
 172                         return 0;
 173                 }
 174         }
 175
 176         return -EINVAL;
 177 }
 178
 179 static int write_machine_id(int fd, char id[34]) {
 180         assert(fd >= 0);
 181         assert(id);
 182         lseek(fd, 0, SEEK_SET);
 183
 184         if (loop_write(fd, id, 33, false) == 0)
 185                 return 0;
 186
 187         return -errno;
 188 }
 189
 190 int machine_id_commit(const char *root) {
 191         _cleanup_close_ int fd = -1, initial_mntns_fd = -1;
 192         const char *etc_machine_id;
 193         char id[34]; /* 32 + \n + \0 */
 194         int r;
 195
 196         if (isempty(root))
 197                 etc_machine_id = "/etc/machine-id";
 198         else {
 199                 char *x;
 200
 201                 x = strjoina(root, "/etc/machine-id");
 202                 etc_machine_id = path_kill_slashes(x);
 203         }
 204
 205         r = path_is_mount_point(etc_machine_id, false);
 206         if (r < 0)
 207                 return log_error_errno(r, "Failed to determine whether %s is a mount point: %m", etc_machine_id);
 208         if (r == 0) {
 209                 log_debug("%s is is not a mount point. Nothing to do.", etc_machine_id);
 210                 return 0;
 211         }
 212
 213         /* Read existing machine-id */
 214         fd = open(etc_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY);
 215         if (fd < 0)
 216                 return log_error_errno(errno, "Cannot open %s: %m", etc_machine_id);
 217
 218         r = get_valid_machine_id(fd, id);
 219         if (r < 0)
 220                 return log_error_errno(r, "We didn't find a valid machine ID in %s.", etc_machine_id);
 221
 222         r = is_fd_on_temporary_fs(fd);
 223         if (r < 0)
 224                 return log_error_errno(r, "Failed to determine whether %s is on a temporary file system: %m", etc_machine_id);
 225         if (r == 0) {
 226                 log_error("%s is not on a temporary file system.", etc_machine_id);
 227                 return -EROFS;
 228         }
 229
 230         fd = safe_close(fd);
 231
 232         /* Store current mount namespace */
 233         r = namespace_open(0, NULL, &initial_mntns_fd, NULL, NULL);
 234         if (r < 0)
 235                 return log_error_errno(r, "Can't fetch current mount namespace: %m");
 236
 237         /* Switch to a new mount namespace, isolate ourself and unmount etc_machine_id in our new namespace */
 238         if (unshare(CLONE_NEWNS) < 0)
 239                 return log_error_errno(errno, "Failed to enter new namespace: %m");
 240
 241         if (mount(NULL, "/", NULL, MS_SLAVE | MS_REC, NULL) < 0)
 242                 return log_error_errno(errno, "Couldn't make-rslave / mountpoint in our private namespace: %m");
 243
 244         if (umount(etc_machine_id) < 0)
 245                 return log_error_errno(errno, "Failed to unmount transient %s file in our private namespace: %m", etc_machine_id);
 246
 247         /* Update a persistent version of etc_machine_id */
 248         fd = open(etc_machine_id, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
 249         if (fd < 0)
 250                 return log_error_errno(errno, "Cannot open for writing %s. This is mandatory to get a persistent machine-id: %m", etc_machine_id);
 251
 252         r = write_machine_id(fd, id);
 253         if (r < 0)
 254                 return log_error_errno(r, "Cannot write %s: %m", etc_machine_id);
 255
 256         fd = safe_close(fd);
 257
 258         /* Return to initial namespace and proceed a lazy tmpfs unmount */
 259         r = namespace_enter(-1, initial_mntns_fd, -1, -1);
 260         if (r < 0)
 261                 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
 263         if (umount2(etc_machine_id, MNT_DETACH) < 0)
 264                 return log_warning_errno(errno, "Failed to unmount transient %s file: %m.\nWe keep that mount until next reboot.", etc_machine_id);
 265
 266         return 0;
 267 }
 268
 269 int machine_id_setup(const char *root) {
 270         const char *etc_machine_id, *run_machine_id;
 271         _cleanup_close_ int fd = -1;
 272         bool writable = true;
 273         struct stat st;
 274         char id[34]; /* 32 + \n + \0 */
 275         int r;
 276
 277         if (isempty(root))  {
 278                 etc_machine_id = "/etc/machine-id";
 279                 run_machine_id = "/run/machine-id";
 280         } else {
 281                 char *x;
 282
 283                 x = strjoina(root, "/etc/machine-id");
 284                 etc_machine_id = path_kill_slashes(x);
 285
 286                 x = strjoina(root, "/run/machine-id");
 287                 run_machine_id = path_kill_slashes(x);
 288         }
 289
 290         RUN_WITH_UMASK(0000) {
 291                 /* We create this 0444, to indicate that this isn't really
 292                  * something you should ever modify. Of course, since the file
 293                  * will be owned by root it doesn't matter much, but maybe
 294                  * people look. */
 295
 296                 mkdir_parents(etc_machine_id, 0755);
 297                 fd = open(etc_machine_id, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0444);
 298                 if (fd < 0) {
 299                         int old_errno = errno;
 300
 301                         fd = open(etc_machine_id, O_RDONLY|O_CLOEXEC|O_NOCTTY);
 302                         if (fd < 0) {
 303                                 if (old_errno == EROFS && errno == ENOENT)
 304                                         log_error("System cannot boot: Missing /etc/machine-id and /etc is mounted read-only.\n"
 305                                                   "Booting up is supported only when:\n"
 306                                                   "1) /etc/machine-id exists and is populated.\n"
 307                                                   "2) /etc/machine-id exists and is empty.\n"
 308                                                   "3) /etc/machine-id is missing and /etc is writable.\n");
 309                                 else
 310                                         log_error_errno(errno, "Cannot open %s: %m", etc_machine_id);
 311                                 return -errno;
 312                         }
 313
 314                         writable = false;
 315                 }
 316         }
 317
 318         if (fstat(fd, &st) < 0)
 319                 return log_error_errno(errno, "fstat() failed: %m");
 320
 321         if (S_ISREG(st.st_mode) && get_valid_machine_id(fd, id) == 0)
 322                 return 0;
 323
 324         /* Hmm, so, the id currently stored is not useful, then let's
 325          * generate one */
 326
 327         r = generate(id, root);
 328         if (r < 0)
 329                 return r;
 330
 331         if (S_ISREG(st.st_mode) && writable)
 332                 if (write_machine_id(fd, id) == 0)
 333                         return 0;
 334
 335         fd = safe_close(fd);
 336
 337         /* Hmm, we couldn't write it? So let's write it to
 338          * /run/machine-id as a replacement */
 339
 340         RUN_WITH_UMASK(0022) {
 341                 r = write_string_file(run_machine_id, id);
 342         }
 343         if (r < 0) {
 344                 log_error_errno(r, "Cannot write %s: %m", run_machine_id);
 345                 unlink(run_machine_id);
 346                 return r;
 347         }
 348
 349         /* And now, let's mount it over */
 350         r = mount(run_machine_id, etc_machine_id, NULL, MS_BIND, NULL);
 351         if (r < 0) {
 352                 log_error_errno(errno, "Failed to mount %s: %m", etc_machine_id);
 353                 unlink_noerrno(run_machine_id);
 354                 return -errno;
 355         }
 356
 357         log_info("Installed transient %s file.", etc_machine_id);
 358
 359         /* Mark the mount read-only */
 360         if (mount(NULL, etc_machine_id, NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, NULL) < 0)
 361                 log_warning_errno(errno, "Failed to make transient %s read-only: %m", etc_machine_id);
 362
 363         return 0;
 364 }