From 293714c0d157ae04d08bb587e800c70f05cc4a29 Mon Sep 17 00:00:00 2001 From: Jeff Mahoney Date: Tue, 9 Apr 2013 14:32:50 +0200 Subject: [PATCH] loopdev: sync capacity after setting it I recently tried to mount an hfsplus file system from an image file with a partition table by using the loop offset and sizelimit options to specify the location of the file system. hfsplus stores some metadata at a set offset from the end of the partition, so it's sensitive to the device size reported by the kernel. It worked with this: But failed with this: /dev/loop0: [0089]:2 (), offset 32768, sizelimit 102400000 /dev/loop1: [0089]:2 (), offset 32768, sizelimit 102400000 /proc/partitions shows the correct number of blocks to match the sizelimit. But if I set a breakpoint in mount before the mount syscall, I could see: 102400000 102432768 The kernel loop driver will set the gendisk capacity of the device at LOOP_SET_STATUS64 but won't sync it to the block device until one of two conditions are met: All open file descriptors referring to the device are closed (and it will sync when re-opened) or if the LOOP_SET_CAPACITY ioctl is called to sync it. Since mount opens the device and passes it directly to the mount syscall after LOOP_SET_STATUS64 without closing and reopening it, the sizelimit argument is effectively ignroed. The capacity needs to be synced immediately for it to work as expected. This patch adds the LOOP_SET_CAPACITY call to loopctx_setup_device since the device isn't yet released to the user, so it's safe to sync the capacity immediately. [kzak@redhat.com: - port to the current git HEAD, - use uint64_t] Signed-off-by: Jeff Mahoney Signed-off-by: Karel Zak --- include/loopdev.h | 1 + lib/Makemodule.am | 2 +- lib/blkdev.c | 3 +- lib/loopdev.c | 86 +++++++++++++++++++++++++++++++++++++++++++-- sys-utils/losetup.c | 19 +++------- sys-utils/mount.8 | 16 +++++++++ 6 files changed, 106 insertions(+), 21 deletions(-) diff --git a/include/loopdev.h b/include/loopdev.h index 6efa0c78f7..9f199a086e 100644 --- a/include/loopdev.h +++ b/include/loopdev.h @@ -163,6 +163,7 @@ extern int loopcxt_next(struct loopdev_cxt *lc); extern int loopcxt_setup_device(struct loopdev_cxt *lc); extern int loopcxt_delete_device(struct loopdev_cxt *lc); +extern int loopcxt_set_capacity(struct loopdev_cxt *lc); int loopcxt_set_offset(struct loopdev_cxt *lc, uint64_t offset); int loopcxt_set_sizelimit(struct loopdev_cxt *lc, uint64_t sizelimit); diff --git a/lib/Makemodule.am b/lib/Makemodule.am index a118958c5a..afc2156c72 100644 --- a/lib/Makemodule.am +++ b/lib/Makemodule.am @@ -70,7 +70,7 @@ test_ttyutils_CFLAGS = -DTEST_PROGRAM test_ttyutils_LDADD = libcommon.la test_blkdev_SOURCES = lib/blkdev.c -test_blkdev_CFLAGS = -DTEST_PROGRAM +test_blkdev_CFLAGS = -DTEST_PROGRAM_BLKDEV test_blkdev_LDADD = libcommon.la test_ismounted_SOURCES = lib/ismounted.c diff --git a/lib/blkdev.c b/lib/blkdev.c index 09c1a2ff3d..f8182c0b3b 100644 --- a/lib/blkdev.c +++ b/lib/blkdev.c @@ -28,7 +28,6 @@ #include "blkdev.h" #include "c.h" #include "linux_version.h" -#include "xalloc.h" static long blkdev_valid_offset (int fd, off_t offset) { @@ -336,7 +335,7 @@ const char *blkdev_scsi_type_to_name(int type) return NULL; } -#ifdef TEST_PROGRAM +#ifdef TEST_PROGRAM_BLKDEV #include #include #include diff --git a/lib/loopdev.c b/lib/loopdev.c index 2a696ab4d6..c35e306f94 100644 --- a/lib/loopdev.c +++ b/lib/loopdev.c @@ -41,6 +41,7 @@ #include "loopdev.h" #include "canonicalize.h" #include "at.h" +#include "blkdev.h" #define CONFIG_LOOPDEV_DEBUG @@ -1071,6 +1072,64 @@ int loopcxt_set_backing_file(struct loopdev_cxt *lc, const char *filename) return 0; } +/* + * In kernels prior to v3.9, if the offset or sizelimit options + * are used, the block device's size won't be synced automatically. + * blockdev --getsize64 and filesystems will use the backing + * file size until the block device has been re-opened or the + * LOOP_SET_CAPACITY ioctl is called to sync the sizes. + * + * Since mount -oloop uses the LO_FLAGS_AUTOCLEAR option and passes + * the open file descriptor to the mount system call, we need to use + * the ioctl. Calling losetup directly doesn't have this problem since + * it closes the device when it exits and whatever consumes the device + * next will re-open it, causing the resync. + */ +static int loopcxt_check_size(struct loopdev_cxt *lc, int file_fd) +{ + uint64_t size, expected_size; + int dev_fd; + struct stat st; + + if (!lc->info.lo_offset && !lc->info.lo_sizelimit) + return 0; + + if (fstat(file_fd, &st)) + return -errno; + + expected_size = st.st_size; + + if (lc->info.lo_offset > 0) + expected_size -= lc->info.lo_offset; + + if (lc->info.lo_sizelimit > 0 && lc->info.lo_sizelimit < expected_size) + expected_size = lc->info.lo_sizelimit; + + dev_fd = loopcxt_get_fd(lc); + if (dev_fd < 0) + return -errno; + + if (blkdev_get_size(dev_fd, (unsigned long long *) &size)) + return -errno; + + if (expected_size != size) { + if (loopcxt_set_capacity(lc)) { + /* ioctl not available */ + if (errno == ENOTTY || errno == EINVAL) + errno = ERANGE; + return -errno; + } + + if (blkdev_get_size(dev_fd, (unsigned long long *) &size)) + return -errno; + + if (expected_size != size) + return -ERANGE; + } + + return 0; +} + /* * @cl: context * @@ -1150,9 +1209,6 @@ int loopcxt_setup_device(struct loopdev_cxt *lc) DBG(lc, loopdev_debug("setup: LOOP_SET_FD: OK")); - close(file_fd); - file_fd = -1; - if (ioctl(dev_fd, LOOP_SET_STATUS64, &lc->info)) { DBG(lc, loopdev_debug("LOOP_SET_STATUS64 failed: %m")); goto err; @@ -1160,6 +1216,12 @@ int loopcxt_setup_device(struct loopdev_cxt *lc) DBG(lc, loopdev_debug("setup: LOOP_SET_STATUS64: OK")); + if ((rc = loopcxt_check_size(lc, file_fd))) + goto err; + + close(file_fd); + file_fd = -1; + memset(&lc->info, 0, sizeof(lc->info)); lc->has_info = 0; lc->info_failed = 0; @@ -1176,6 +1238,24 @@ err: return rc; } +int loopcxt_set_capacity(struct loopdev_cxt *lc) +{ + int fd = loopcxt_get_fd(lc); + + if (fd < 0) + return -EINVAL; + + /* Kernels prior to v2.6.30 don't support this ioctl */ + if (ioctl(fd, LOOP_SET_CAPACITY, 0) < 0) { + int rc = -errno; + DBG(lc, loopdev_debug("LOOP_SET_CAPACITY failed: %m")); + return rc; + } + + DBG(lc, loopdev_debug("capacity set")); + return 0; +} + int loopcxt_delete_device(struct loopdev_cxt *lc) { int fd = loopcxt_get_fd(lc); diff --git a/sys-utils/losetup.c b/sys-utils/losetup.c index 8f3614e1f5..ccf120e9f4 100644 --- a/sys-utils/losetup.c +++ b/sys-utils/losetup.c @@ -183,20 +183,6 @@ static int show_all_loops(struct loopdev_cxt *lc, const char *file, return 0; } -static int set_capacity(struct loopdev_cxt *lc) -{ - int fd = loopcxt_get_fd(lc); - - if (fd < 0) - warn(_("cannot open %s"), loopcxt_get_device(lc)); - else if (ioctl(fd, LOOP_SET_CAPACITY) != 0) - warnx(_("%s: set capacity failed"), loopcxt_get_device(lc)); - else - return 0; - - return -1; -} - static int delete_loop(struct loopdev_cxt *lc) { if (loopcxt_delete_device(lc)) @@ -685,7 +671,10 @@ int main(int argc, char **argv) warn(_("%s"), loopcxt_get_device(&lc)); break; case A_SET_CAPACITY: - res = set_capacity(&lc); + res = loopcxt_set_capacity(&lc); + if (res) + warn(_("%s: set capacity failed"), + loopcxt_get_device(&lc)); break; default: usage(stderr); diff --git a/sys-utils/mount.8 b/sys-utils/mount.8 index 72f0f0b456..626d861691 100644 --- a/sys-utils/mount.8 +++ b/sys-utils/mount.8 @@ -2976,6 +2976,22 @@ and .BR ioctl families of functions) may lead to inconsistent result due to the lack of consistency check in kernel even if noac is used. +.PP +The +.B loop +option with the +.B offset +or +.B sizelimit +options used may fail when using older kernels if the +.B mount +command can't confirm that the size of the block device has been configured +as requested. This situation can be worked around by using +the +.B losetup +command manually before calling +.B mount +with the configured loop device. .SH HISTORY A .B mount -- 2.47.2