src/shared/loop-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #if HAVE_VALGRIND_MEMCHECK_H
   4 #include <valgrind/memcheck.h>
   5 #endif
   6
   7 #include <errno.h>
   8 #include <fcntl.h>
   9 #include <linux/blkpg.h>
  10 #include <linux/fs.h>
  11 #include <linux/loop.h>
  12 #include <sys/file.h>
  13 #include <sys/ioctl.h>
  14 #include <unistd.h>
  15
  16 #include "alloc-util.h"
  17 #include "errno-util.h"
  18 #include "fd-util.h"
  19 #include "fileio.h"
  20 #include "loop-util.h"
  21 #include "parse-util.h"
  22 #include "stat-util.h"
  23 #include "stdio-util.h"
  24 #include "string-util.h"
  25
  26 static void cleanup_clear_loop_close(int *fd) {
  27         if (*fd >= 0) {
  28                 (void) ioctl(*fd, LOOP_CLR_FD);
  29                 (void) safe_close(*fd);
  30         }
  31 }
  32
  33 int loop_device_make(
  34                 int fd,
  35                 int open_flags,
  36                 uint64_t offset,
  37                 uint64_t size,
  38                 uint32_t loop_flags,
  39                 LoopDevice **ret) {
  40
  41         _cleanup_free_ char *loopdev = NULL;
  42         struct loop_info64 info;
  43         LoopDevice *d = NULL;
  44         struct stat st;
  45         int nr = -1, r;
  46
  47         assert(fd >= 0);
  48         assert(ret);
  49         assert(IN_SET(open_flags, O_RDWR, O_RDONLY));
  50
  51         if (fstat(fd, &st) < 0)
  52                 return -errno;
  53
  54         if (S_ISBLK(st.st_mode)) {
  55                 if (ioctl(fd, LOOP_GET_STATUS64, &info) >= 0) {
  56                         /* Oh! This is a loopback device? That's interesting! */
  57
  58 #if HAVE_VALGRIND_MEMCHECK_H
  59                         /* Valgrind currently doesn't know LOOP_GET_STATUS64. Remove this once it does */
  60                         VALGRIND_MAKE_MEM_DEFINED(&info, sizeof(info));
  61 #endif
  62                         nr = info.lo_number;
  63
  64                         if (asprintf(&loopdev, "/dev/loop%i", nr) < 0)
  65                                 return -ENOMEM;
  66                 }
  67
  68                 if (offset == 0 && IN_SET(size, 0, UINT64_MAX)) {
  69                         _cleanup_close_ int copy = -1;
  70
  71                         /* If this is already a block device, store a copy of the fd as it is */
  72
  73                         copy = fcntl(fd, F_DUPFD_CLOEXEC, 3);
  74                         if (copy < 0)
  75                                 return -errno;
  76
  77                         d = new(LoopDevice, 1);
  78                         if (!d)
  79                                 return -ENOMEM;
  80                         *d = (LoopDevice) {
  81                                 .fd = TAKE_FD(copy),
  82                                 .nr = nr,
  83                                 .node = TAKE_PTR(loopdev),
  84                                 .relinquished = true, /* It's not allocated by us, don't destroy it when this object is freed */
  85                         };
  86
  87                         *ret = d;
  88                         return d->fd;
  89                 }
  90         } else {
  91                 r = stat_verify_regular(&st);
  92                 if (r < 0)
  93                         return r;
  94         }
  95
  96         _cleanup_close_ int control = -1;
  97         _cleanup_(cleanup_clear_loop_close) int loop_with_fd = -1;
  98
  99         control = open("/dev/loop-control", O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
 100         if (control < 0)
 101                 return -errno;
 102
 103         /* Loop around LOOP_CTL_GET_FREE, since at the moment we attempt to open the returned device it might
 104          * be gone already, taken by somebody else racing against us. */
 105         for (unsigned n_attempts = 0;;) {
 106                 _cleanup_close_ int loop = -1;
 107
 108                 nr = ioctl(control, LOOP_CTL_GET_FREE);
 109                 if (nr < 0)
 110                         return -errno;
 111
 112                 if (asprintf(&loopdev, "/dev/loop%i", nr) < 0)
 113                         return -ENOMEM;
 114
 115                 loop = open(loopdev, O_CLOEXEC|O_NONBLOCK|O_NOCTTY|open_flags);
 116                 if (loop < 0) {
 117                         /* Somebody might've gotten the same number from the kernel, used the device,
 118                          * and called LOOP_CTL_REMOVE on it. Let's retry with a new number. */
 119                         if (errno != ENOENT)
 120                                 return -errno;
 121                 } else {
 122                         if (ioctl(loop, LOOP_SET_FD, fd) >= 0) {
 123                                 loop_with_fd = TAKE_FD(loop);
 124                                 break;
 125                         }
 126                         if (errno != EBUSY)
 127                                 return -errno;
 128                 }
 129
 130                 if (++n_attempts >= 64) /* Give up eventually */
 131                         return -EBUSY;
 132
 133                 loopdev = mfree(loopdev);
 134         }
 135
 136         info = (struct loop_info64) {
 137                 /* Use the specified flags, but configure the read-only flag from the open flags, and force autoclear */
 138                 .lo_flags = (loop_flags & ~LO_FLAGS_READ_ONLY) | ((loop_flags & O_ACCMODE) == O_RDONLY ? LO_FLAGS_READ_ONLY : 0) | LO_FLAGS_AUTOCLEAR,
 139                 .lo_offset = offset,
 140                 .lo_sizelimit = size == UINT64_MAX ? 0 : size,
 141         };
 142
 143         if (ioctl(loop_with_fd, LOOP_SET_STATUS64, &info) < 0)
 144                 return -errno;
 145
 146         d = new(LoopDevice, 1);
 147         if (!d)
 148                 return -ENOMEM;
 149         *d = (LoopDevice) {
 150                 .fd = TAKE_FD(loop_with_fd),
 151                 .node = TAKE_PTR(loopdev),
 152                 .nr = nr,
 153         };
 154
 155         *ret = d;
 156         return 0;
 157 }
 158
 159 int loop_device_make_by_path(const char *path, int open_flags, uint32_t loop_flags, LoopDevice **ret) {
 160         _cleanup_close_ int fd = -1;
 161         int r;
 162
 163         assert(path);
 164         assert(ret);
 165         assert(open_flags < 0 || IN_SET(open_flags, O_RDWR, O_RDONLY));
 166
 167         /* Passing < 0 as open_flags here means we'll try to open the device writable if we can, retrying
 168          * read-only if we cannot. */
 169
 170         fd = open(path, O_CLOEXEC|O_NONBLOCK|O_NOCTTY|(open_flags >= 0 ? open_flags : O_RDWR));
 171         if (fd < 0) {
 172                 r = -errno;
 173
 174                 /* Retry read-only? */
 175                 if (open_flags >= 0 || !(ERRNO_IS_PRIVILEGE(r) || r == -EROFS))
 176                         return r;
 177
 178                 fd = open(path, O_CLOEXEC|O_NONBLOCK|O_NOCTTY|O_RDONLY);
 179                 if (fd < 0)
 180                         return r; /* Propagate original error */
 181
 182                 open_flags = O_RDONLY;
 183         } else if (open_flags < 0)
 184                 open_flags = O_RDWR;
 185
 186         return loop_device_make(fd, open_flags, 0, 0, loop_flags, ret);
 187 }
 188
 189 LoopDevice* loop_device_unref(LoopDevice *d) {
 190         if (!d)
 191                 return NULL;
 192
 193         if (d->fd >= 0) {
 194                 /* Implicitly sync the device, since otherwise in-flight blocks might not get written */
 195                 if (fsync(d->fd) < 0)
 196                         log_debug_errno(errno, "Failed to sync loop block device, ignoring: %m");
 197
 198                 if (d->nr >= 0 && !d->relinquished) {
 199                         if (ioctl(d->fd, LOOP_CLR_FD) < 0)
 200                                 log_debug_errno(errno, "Failed to clear loop device: %m");
 201
 202                 }
 203
 204                 safe_close(d->fd);
 205         }
 206
 207         if (d->nr >= 0 && !d->relinquished) {
 208                 _cleanup_close_ int control = -1;
 209
 210                 control = open("/dev/loop-control", O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
 211                 if (control < 0)
 212                         log_warning_errno(errno,
 213                                           "Failed to open loop control device, cannot remove loop device %s: %m",
 214                                           strna(d->node));
 215                 else
 216                         for (unsigned n_attempts = 0;;) {
 217                                 if (ioctl(control, LOOP_CTL_REMOVE, d->nr) >= 0)
 218                                         break;
 219                                 if (errno != EBUSY || ++n_attempts >= 64) {
 220                                         log_warning_errno(errno, "Failed to remove device %s: %m", strna(d->node));
 221                                         break;
 222                                 }
 223                                 (void) usleep(50 * USEC_PER_MSEC);
 224                         }
 225         }
 226
 227         free(d->node);
 228         return mfree(d);
 229 }
 230
 231 void loop_device_relinquish(LoopDevice *d) {
 232         assert(d);
 233
 234         /* Don't attempt to clean up the loop device anymore from this point on. Leave the clean-ing up to the kernel
 235          * itself, using the loop device "auto-clear" logic we already turned on when creating the device. */
 236
 237         d->relinquished = true;
 238 }
 239
 240 int loop_device_open(const char *loop_path, int open_flags, LoopDevice **ret) {
 241         _cleanup_close_ int loop_fd = -1;
 242         _cleanup_free_ char *p = NULL;
 243         struct loop_info64 info;
 244         struct stat st;
 245         LoopDevice *d;
 246         int nr;
 247
 248         assert(loop_path);
 249         assert(ret);
 250
 251         loop_fd = open(loop_path, O_CLOEXEC|O_NONBLOCK|O_NOCTTY|open_flags);
 252         if (loop_fd < 0)
 253                 return -errno;
 254
 255         if (fstat(loop_fd, &st) < 0)
 256                 return -errno;
 257         if (!S_ISBLK(st.st_mode))
 258                 return -ENOTBLK;
 259
 260         if (ioctl(loop_fd, LOOP_GET_STATUS64, &info) >= 0) {
 261 #if HAVE_VALGRIND_MEMCHECK_H
 262                 /* Valgrind currently doesn't know LOOP_GET_STATUS64. Remove this once it does */
 263                 VALGRIND_MAKE_MEM_DEFINED(&info, sizeof(info));
 264 #endif
 265                 nr = info.lo_number;
 266         } else
 267                 nr = -1;
 268
 269         p = strdup(loop_path);
 270         if (!p)
 271                 return -ENOMEM;
 272
 273         d = new(LoopDevice, 1);
 274         if (!d)
 275                 return -ENOMEM;
 276
 277         *d = (LoopDevice) {
 278                 .fd = TAKE_FD(loop_fd),
 279                 .nr = nr,
 280                 .node = TAKE_PTR(p),
 281                 .relinquished = true, /* It's not ours, don't try to destroy it when this object is freed */
 282         };
 283
 284         *ret = d;
 285         return d->fd;
 286 }
 287
 288 static int resize_partition(int partition_fd, uint64_t offset, uint64_t size) {
 289         char sysfs[STRLEN("/sys/dev/block/:/partition") + 2*DECIMAL_STR_MAX(dev_t) + 1];
 290         _cleanup_free_ char *whole = NULL, *buffer = NULL;
 291         uint64_t current_offset, current_size, partno;
 292         _cleanup_close_ int whole_fd = -1;
 293         struct stat st;
 294         dev_t devno;
 295         int r;
 296
 297         assert(partition_fd >= 0);
 298
 299         /* Resizes the partition the loopback device refer to (assuming it refers to one instead of an actual
 300          * loopback device), and changes the offset, if needed. This is a fancy wrapper around
 301          * BLKPG_RESIZE_PARTITION. */
 302
 303         if (fstat(partition_fd, &st) < 0)
 304                 return -errno;
 305
 306         assert(S_ISBLK(st.st_mode));
 307
 308         xsprintf(sysfs, "/sys/dev/block/%u:%u/partition", major(st.st_rdev), minor(st.st_rdev));
 309         r = read_one_line_file(sysfs, &buffer);
 310         if (r == -ENOENT) /* not a partition, cannot resize */
 311                 return -ENOTTY;
 312         if (r < 0)
 313                 return r;
 314         r = safe_atou64(buffer, &partno);
 315         if (r < 0)
 316                 return r;
 317
 318         xsprintf(sysfs, "/sys/dev/block/%u:%u/start", major(st.st_rdev), minor(st.st_rdev));
 319
 320         buffer = mfree(buffer);
 321         r = read_one_line_file(sysfs, &buffer);
 322         if (r < 0)
 323                 return r;
 324         r = safe_atou64(buffer, &current_offset);
 325         if (r < 0)
 326                 return r;
 327         if (current_offset > UINT64_MAX/512U)
 328                 return -EINVAL;
 329         current_offset *= 512U;
 330
 331         if (ioctl(partition_fd, BLKGETSIZE64, &current_size) < 0)
 332                 return -EINVAL;
 333
 334         if (size == UINT64_MAX && offset == UINT64_MAX)
 335                 return 0;
 336         if (current_size == size && current_offset == offset)
 337                 return 0;
 338
 339         xsprintf(sysfs, "/sys/dev/block/%u:%u/../dev", major(st.st_rdev), minor(st.st_rdev));
 340
 341         buffer = mfree(buffer);
 342         r = read_one_line_file(sysfs, &buffer);
 343         if (r < 0)
 344                 return r;
 345         r = parse_dev(buffer, &devno);
 346         if (r < 0)
 347                 return r;
 348
 349         r = device_path_make_major_minor(S_IFBLK, devno, &whole);
 350         if (r < 0)
 351                 return r;
 352
 353         whole_fd = open(whole, O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
 354         if (whole_fd < 0)
 355                 return -errno;
 356
 357         struct blkpg_partition bp = {
 358                 .pno = partno,
 359                 .start = offset == UINT64_MAX ? current_offset : offset,
 360                 .length = size == UINT64_MAX ? current_size : size,
 361         };
 362
 363         struct blkpg_ioctl_arg ba = {
 364                 .op = BLKPG_RESIZE_PARTITION,
 365                 .data = &bp,
 366                 .datalen = sizeof(bp),
 367         };
 368
 369         if (ioctl(whole_fd, BLKPG, &ba) < 0)
 370                 return -errno;
 371
 372         return 0;
 373 }
 374
 375 int loop_device_refresh_size(LoopDevice *d, uint64_t offset, uint64_t size) {
 376         struct loop_info64 info;
 377         assert(d);
 378
 379         /* Changes the offset/start of the loop device relative to the beginning of the underlying file or
 380          * block device. If this loop device actually refers to a partition and not a loopback device, we'll
 381          * try to adjust the partition offsets instead.
 382          *
 383          * If either offset or size is UINT64_MAX we won't change that parameter. */
 384
 385         if (d->fd < 0)
 386                 return -EBADF;
 387
 388         if (d->nr < 0) /* not a loopback device */
 389                 return resize_partition(d->fd, offset, size);
 390
 391         if (ioctl(d->fd, LOOP_GET_STATUS64, &info) < 0)
 392                 return -errno;
 393
 394 #if HAVE_VALGRIND_MEMCHECK_H
 395         /* Valgrind currently doesn't know LOOP_GET_STATUS64. Remove this once it does */
 396         VALGRIND_MAKE_MEM_DEFINED(&info, sizeof(info));
 397 #endif
 398
 399         if (size == UINT64_MAX && offset == UINT64_MAX)
 400                 return 0;
 401         if (info.lo_sizelimit == size && info.lo_offset == offset)
 402                 return 0;
 403
 404         if (size != UINT64_MAX)
 405                 info.lo_sizelimit = size;
 406         if (offset != UINT64_MAX)
 407                 info.lo_offset = offset;
 408
 409         if (ioctl(d->fd, LOOP_SET_STATUS64, &info) < 0)
 410                 return -errno;
 411
 412         return 0;
 413 }
 414
 415 int loop_device_flock(LoopDevice *d, int operation) {
 416         assert(d);
 417
 418         if (d->fd < 0)
 419                 return -EBADF;
 420
 421         if (flock(d->fd, operation) < 0)
 422                 return -errno;
 423
 424         return 0;
 425 }