src/shared/machine-pool.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include <linux/loop.h>
   6 #include <signal.h>
   7 #include <stdbool.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <sys/file.h>
  11 #include <sys/ioctl.h>
  12 #include <sys/mount.h>
  13 #include <sys/prctl.h>
  14 #include <sys/stat.h>
  15 #include <sys/statfs.h>
  16 #include <sys/statvfs.h>
  17 #include <unistd.h>
  18
  19 #include "sd-bus-protocol.h"
  20 #include "sd-bus.h"
  21
  22 #include "alloc-util.h"
  23 #include "btrfs-util.h"
  24 #include "fd-util.h"
  25 #include "fileio.h"
  26 #include "fs-util.h"
  27 #include "label.h"
  28 #include "lockfile-util.h"
  29 #include "log.h"
  30 #include "machine-pool.h"
  31 #include "macro.h"
  32 #include "missing.h"
  33 #include "mkdir.h"
  34 #include "mount-util.h"
  35 #include "parse-util.h"
  36 #include "path-util.h"
  37 #include "process-util.h"
  38 #include "signal-util.h"
  39 #include "stat-util.h"
  40 #include "string-util.h"
  41
  42 #define VAR_LIB_MACHINES_SIZE_START (1024UL*1024UL*500UL)
  43 #define VAR_LIB_MACHINES_FREE_MIN (1024UL*1024UL*750UL)
  44
  45 static int check_btrfs(void) {
  46         struct statfs sfs;
  47
  48         if (statfs("/var/lib/machines", &sfs) < 0) {
  49                 if (errno != ENOENT)
  50                         return -errno;
  51
  52                 if (statfs("/var/lib", &sfs) < 0)
  53                         return -errno;
  54         }
  55
  56         return F_TYPE_EQUAL(sfs.f_type, BTRFS_SUPER_MAGIC);
  57 }
  58
  59 static int setup_machine_raw(uint64_t size, sd_bus_error *error) {
  60         _cleanup_free_ char *tmp = NULL;
  61         _cleanup_close_ int fd = -1;
  62         struct statvfs ss;
  63         pid_t pid = 0;
  64         int r;
  65
  66         /* We want to be able to make use of btrfs-specific file
  67          * system features, in particular subvolumes, reflinks and
  68          * quota. Hence, if we detect that /var/lib/machines.raw is
  69          * not located on btrfs, let's create a loopback file, place a
  70          * btrfs file system into it, and mount it to
  71          * /var/lib/machines. */
  72
  73         fd = open("/var/lib/machines.raw", O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
  74         if (fd >= 0)
  75                 return TAKE_FD(fd);
  76
  77         if (errno != ENOENT)
  78                 return sd_bus_error_set_errnof(error, errno, "Failed to open /var/lib/machines.raw: %m");
  79
  80         r = tempfn_xxxxxx("/var/lib/machines.raw", NULL, &tmp);
  81         if (r < 0)
  82                 return r;
  83
  84         (void) mkdir_p_label("/var/lib", 0755);
  85         fd = open(tmp, O_RDWR|O_CREAT|O_EXCL|O_NOCTTY|O_CLOEXEC, 0600);
  86         if (fd < 0)
  87                 return sd_bus_error_set_errnof(error, errno, "Failed to create /var/lib/machines.raw: %m");
  88
  89         if (fstatvfs(fd, &ss) < 0) {
  90                 r = sd_bus_error_set_errnof(error, errno, "Failed to determine free space on /var/lib/machines.raw: %m");
  91                 goto fail;
  92         }
  93
  94         if (ss.f_bsize * ss.f_bavail < VAR_LIB_MACHINES_FREE_MIN) {
  95                 r = sd_bus_error_setf(error, SD_BUS_ERROR_FAILED, "Not enough free disk space to set up /var/lib/machines.");
  96                 goto fail;
  97         }
  98
  99         if (ftruncate(fd, size) < 0) {
 100                 r = sd_bus_error_set_errnof(error, errno, "Failed to enlarge /var/lib/machines.raw: %m");
 101                 goto fail;
 102         }
 103
 104         r = safe_fork("(mkfs)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &pid);
 105         if (r < 0) {
 106                 sd_bus_error_set_errnof(error, r, "Failed to fork mkfs.btrfs: %m");
 107                 goto fail;
 108         }
 109         if (r == 0) {
 110
 111                 /* Child */
 112
 113                 fd = safe_close(fd);
 114
 115                 execlp("mkfs.btrfs", "-Lvar-lib-machines", tmp, NULL);
 116                 if (errno == ENOENT)
 117                         _exit(99);
 118
 119                 _exit(EXIT_FAILURE);
 120         }
 121
 122         r = wait_for_terminate_and_check("mkfs", pid, 0);
 123         pid = 0;
 124
 125         if (r < 0) {
 126                 sd_bus_error_set_errnof(error, r, "Failed to wait for mkfs.btrfs: %m");
 127                 goto fail;
 128         }
 129         if (r == 99) {
 130                 r = sd_bus_error_set_errnof(error, ENOENT, "Cannot set up /var/lib/machines, mkfs.btrfs is missing");
 131                 goto fail;
 132         }
 133         if (r != EXIT_SUCCESS) {
 134                 r = sd_bus_error_setf(error, SD_BUS_ERROR_FAILED, "mkfs.btrfs failed with error code %i", r);
 135                 goto fail;
 136         }
 137
 138         r = rename_noreplace(AT_FDCWD, tmp, AT_FDCWD, "/var/lib/machines.raw");
 139         if (r < 0) {
 140                 sd_bus_error_set_errnof(error, r, "Failed to move /var/lib/machines.raw into place: %m");
 141                 goto fail;
 142         }
 143
 144         return TAKE_FD(fd);
 145
 146 fail:
 147         unlink_noerrno(tmp);
 148
 149         if (pid > 1)
 150                 kill_and_sigcont(pid, SIGKILL);
 151
 152         return r;
 153 }
 154
 155 int setup_machine_directory(uint64_t size, sd_bus_error *error) {
 156         _cleanup_(release_lock_file) LockFile lock_file = LOCK_FILE_INIT;
 157         struct loop_info64 info = {
 158                 .lo_flags = LO_FLAGS_AUTOCLEAR,
 159         };
 160         _cleanup_close_ int fd = -1, control = -1, loop = -1;
 161         _cleanup_free_ char* loopdev = NULL;
 162         char tmpdir[] = "/tmp/machine-pool.XXXXXX", *mntdir = NULL;
 163         bool tmpdir_made = false, mntdir_made = false, mntdir_mounted = false;
 164         char buf[FORMAT_BYTES_MAX];
 165         int r, nr = -1;
 166
 167         /* btrfs cannot handle file systems < 16M, hence use this as minimum */
 168         if (size == (uint64_t) -1)
 169                 size = VAR_LIB_MACHINES_SIZE_START;
 170         else if (size < 16*1024*1024)
 171                 size = 16*1024*1024;
 172
 173         /* Make sure we only set the directory up once at a time */
 174         r = make_lock_file("/run/systemd/machines.lock", LOCK_EX, &lock_file);
 175         if (r < 0)
 176                 return r;
 177
 178         r = check_btrfs();
 179         if (r < 0)
 180                 return sd_bus_error_set_errnof(error, r, "Failed to determine whether /var/lib/machines is located on btrfs: %m");
 181         if (r > 0) {
 182                 (void) btrfs_subvol_make_label("/var/lib/machines");
 183
 184                 r = btrfs_quota_enable("/var/lib/machines", true);
 185                 if (r < 0)
 186                         log_warning_errno(r, "Failed to enable quota for /var/lib/machines, ignoring: %m");
 187
 188                 r = btrfs_subvol_auto_qgroup("/var/lib/machines", 0, true);
 189                 if (r < 0)
 190                         log_warning_errno(r, "Failed to set up default quota hierarchy for /var/lib/machines, ignoring: %m");
 191
 192                 return 1;
 193         }
 194
 195         if (path_is_mount_point("/var/lib/machines", NULL, AT_SYMLINK_FOLLOW) > 0) {
 196                 log_debug("/var/lib/machines is already a mount point, not creating loopback file for it.");
 197                 return 0;
 198         }
 199
 200         r = dir_is_populated("/var/lib/machines");
 201         if (r < 0 && r != -ENOENT)
 202                 return r;
 203         if (r > 0) {
 204                 log_debug("/var/log/machines is already populated, not creating loopback file for it.");
 205                 return 0;
 206         }
 207
 208         r = mkfs_exists("btrfs");
 209         if (r == 0)
 210                 return sd_bus_error_set_errnof(error, ENOENT, "Cannot set up /var/lib/machines, mkfs.btrfs is missing");
 211         if (r < 0)
 212                 return r;
 213
 214         fd = setup_machine_raw(size, error);
 215         if (fd < 0)
 216                 return fd;
 217
 218         control = open("/dev/loop-control", O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
 219         if (control < 0)
 220                 return sd_bus_error_set_errnof(error, errno, "Failed to open /dev/loop-control: %m");
 221
 222         nr = ioctl(control, LOOP_CTL_GET_FREE);
 223         if (nr < 0)
 224                 return sd_bus_error_set_errnof(error, errno, "Failed to allocate loop device: %m");
 225
 226         if (asprintf(&loopdev, "/dev/loop%i", nr) < 0) {
 227                 r = -ENOMEM;
 228                 goto fail;
 229         }
 230
 231         loop = open(loopdev, O_CLOEXEC|O_RDWR|O_NOCTTY|O_NONBLOCK);
 232         if (loop < 0) {
 233                 r = sd_bus_error_set_errnof(error, errno, "Failed to open loopback device: %m");
 234                 goto fail;
 235         }
 236
 237         if (ioctl(loop, LOOP_SET_FD, fd) < 0) {
 238                 r = sd_bus_error_set_errnof(error, errno, "Failed to bind loopback device: %m");
 239                 goto fail;
 240         }
 241
 242         if (ioctl(loop, LOOP_SET_STATUS64, &info) < 0) {
 243                 r = sd_bus_error_set_errnof(error, errno, "Failed to enable auto-clear for loopback device: %m");
 244                 goto fail;
 245         }
 246
 247         /* We need to make sure the new /var/lib/machines directory
 248          * has an access mode of 0700 at the time it is first made
 249          * available. mkfs will create it with 0755 however. Hence,
 250          * let's mount the directory into an inaccessible directory
 251          * below /tmp first, fix the access mode, and move it to the
 252          * public place then. */
 253
 254         if (!mkdtemp(tmpdir)) {
 255                 r = sd_bus_error_set_errnof(error, errno, "Failed to create temporary mount parent directory: %m");
 256                 goto fail;
 257         }
 258         tmpdir_made = true;
 259
 260         mntdir = strjoina(tmpdir, "/mnt");
 261         if (mkdir(mntdir, 0700) < 0) {
 262                 r = sd_bus_error_set_errnof(error, errno, "Failed to create temporary mount directory: %m");
 263                 goto fail;
 264         }
 265         mntdir_made = true;
 266
 267         if (mount(loopdev, mntdir, "btrfs", 0, NULL) < 0) {
 268                 r = sd_bus_error_set_errnof(error, errno, "Failed to mount loopback device: %m");
 269                 goto fail;
 270         }
 271         mntdir_mounted = true;
 272
 273         r = btrfs_quota_enable(mntdir, true);
 274         if (r < 0)
 275                 log_warning_errno(r, "Failed to enable quota, ignoring: %m");
 276
 277         r = btrfs_subvol_auto_qgroup(mntdir, 0, true);
 278         if (r < 0)
 279                 log_warning_errno(r, "Failed to set up default quota hierarchy, ignoring: %m");
 280
 281         if (chmod(mntdir, 0700) < 0) {
 282                 r = sd_bus_error_set_errnof(error, errno, "Failed to fix owner: %m");
 283                 goto fail;
 284         }
 285
 286         (void) mkdir_p_label("/var/lib/machines", 0700);
 287
 288         if (mount(mntdir, "/var/lib/machines", NULL, MS_BIND, NULL) < 0) {
 289                 r = sd_bus_error_set_errnof(error, errno, "Failed to mount directory into right place: %m");
 290                 goto fail;
 291         }
 292
 293         (void) syncfs(fd);
 294
 295         log_info("Set up /var/lib/machines as btrfs loopback file system of size %s mounted on /var/lib/machines.raw.", format_bytes(buf, sizeof(buf), size));
 296
 297         (void) umount2(mntdir, MNT_DETACH);
 298         (void) rmdir(mntdir);
 299         (void) rmdir(tmpdir);
 300
 301         return 1;
 302
 303 fail:
 304         if (mntdir_mounted)
 305                 (void) umount2(mntdir, MNT_DETACH);
 306
 307         if (mntdir_made)
 308                 (void) rmdir(mntdir);
 309         if (tmpdir_made)
 310                 (void) rmdir(tmpdir);
 311
 312         if (loop >= 0) {
 313                 (void) ioctl(loop, LOOP_CLR_FD);
 314                 loop = safe_close(loop);
 315         }
 316
 317         (void) ioctl(control, LOOP_CTL_REMOVE, nr);
 318
 319         return r;
 320 }
 321
 322 static int sync_path(const char *p) {
 323         _cleanup_close_ int fd = -1;
 324
 325         fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY);
 326         if (fd < 0)
 327                 return -errno;
 328
 329         if (syncfs(fd) < 0)
 330                 return -errno;
 331
 332         return 0;
 333 }
 334
 335 int grow_machine_directory(void) {
 336         char buf[FORMAT_BYTES_MAX];
 337         struct statvfs a, b;
 338         uint64_t old_size, new_size, max_add;
 339         int r;
 340
 341         /* Ensure the disk space data is accurate */
 342         sync_path("/var/lib/machines");
 343         sync_path("/var/lib/machines.raw");
 344
 345         if (statvfs("/var/lib/machines.raw", &a) < 0)
 346                 return -errno;
 347
 348         if (statvfs("/var/lib/machines", &b) < 0)
 349                 return -errno;
 350
 351         /* Don't grow if not enough disk space is available on the host */
 352         if (((uint64_t) a.f_bavail * (uint64_t) a.f_bsize) <= VAR_LIB_MACHINES_FREE_MIN)
 353                 return 0;
 354
 355         /* Don't grow if at least 1/3th of the fs is still free */
 356         if (b.f_bavail > b.f_blocks / 3)
 357                 return 0;
 358
 359         /* Calculate how much we are willing to add at most */
 360         max_add = ((uint64_t) a.f_bavail * (uint64_t) a.f_bsize) - VAR_LIB_MACHINES_FREE_MIN;
 361
 362         /* Calculate the old size */
 363         old_size = (uint64_t) b.f_blocks * (uint64_t) b.f_bsize;
 364
 365         /* Calculate the new size as three times the size of what is used right now */
 366         new_size = ((uint64_t) b.f_blocks - (uint64_t) b.f_bavail) * (uint64_t) b.f_bsize * 3;
 367
 368         /* Always, grow at least to the start size */
 369         if (new_size < VAR_LIB_MACHINES_SIZE_START)
 370                 new_size = VAR_LIB_MACHINES_SIZE_START;
 371
 372         /* If the new size is smaller than the old size, don't grow */
 373         if (new_size < old_size)
 374                 return 0;
 375
 376         /* Ensure we never add more than the maximum */
 377         if (new_size > old_size + max_add)
 378                 new_size = old_size + max_add;
 379
 380         r = btrfs_resize_loopback("/var/lib/machines", new_size, true);
 381         if (r < 0)
 382                 return log_debug_errno(r, "Failed to resize loopback: %m");
 383         if (r == 0)
 384                 return 0;
 385
 386         /* Also bump the quota, of both the subvolume leaf qgroup, as
 387          * well as of any subtree quota group by the same id but a
 388          * higher level, if it exists. */
 389         r = btrfs_qgroup_set_limit("/var/lib/machines", 0, new_size);
 390         if (r < 0)
 391                 log_debug_errno(r, "Failed to set btrfs limit: %m");
 392
 393         r = btrfs_subvol_set_subtree_quota_limit("/var/lib/machines", 0, new_size);
 394         if (r < 0)
 395                 log_debug_errno(r, "Failed to set btrfs subtree limit: %m");
 396
 397         log_info("Grew /var/lib/machines btrfs loopback file system to %s.", format_bytes(buf, sizeof(buf), new_size));
 398         return 1;
 399 }