Skip to contentSkip to conversation

loop: change queue block size to match when using DIO.

PATCH Superseded Martijn Coenen 3 participants 8 messages Aug 28, 2019 – Oct 1, 2019 Block layer

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 loop: change queue block size to match when using DIO.

The loop driver assumes that if the passed in fd is opened with O_DIRECT, the caller wants to use direct I/O on the loop device. However, if the underlying filesystem has a different block size than the loop block queue, direct I/O can't be enabled. Instead of requiring userspace to manually change the blocksize and re-enable direct I/O, just change the queue block size to match.

---
 drivers/block/loop.c | 6 ++++++
 1 file changed, 6 insertions(+)
drivers/block/loop.c +6 -0
index ab7ca5989097a..1138162ff6c4d 100644
@@ -994,6 +994,12 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
 	if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
 		blk_queue_write_cache(lo->lo_queue, true, false);
 
+	if (io_is_direct(lo->lo_backing_file) && inode->i_sb->s_bdev) {
+		/* In case of direct I/O, match underlying block size */
+		blk_queue_logical_block_size(lo->lo_queue,
+				bdev_logical_block_size(inode->i_sb->s_bdev));
+	}
+
 	loop_update_rotational(lo);
 	loop_update_dio(lo);
 	set_capacity(lo->lo_disk, size);
Signature · 1 line
2.23.0.187.g17f5b7556c-goog
#1 lore raw
Quoted 6 lines · Martijn Coenen

The loop driver assumes that if the passed in fd is opened with O_DIRECT, the caller wants to use direct I/O on the loop device. However, if the underlying filesystem has a different block size than the loop block queue, direct I/O can't be enabled. Instead of requiring userspace to manually change the blocksize and re-enable direct I/O, just change the queue block size to match.

Why can't we enable the block device in that case? All the usual block filesystems support 512 byte aligned direct I/O with a 4k file system block size (as long as the underlying block device sector size is also 512 bytes).

#2 lore raw
Quoted 9 lines · Christoph Hellwig
Quoted 6 lines · Martijn Coenen

The loop driver assumes that if the passed in fd is opened with O_DIRECT, the caller wants to use direct I/O on the loop device. However, if the underlying filesystem has a different block size than the loop block queue, direct I/O can't be enabled. Instead of requiring userspace to manually change the blocksize and re-enable direct I/O, just change the queue block size to match.

Quoted 4 lines

Why can't we enable the block device in that case? All the usual block filesystems support 512 byte aligned direct I/O with a 4k file system block size (as long as the underlying block device sector size is also 512 bytes).

Sorry, I didn't word that correctly: it's not the logical block size of the filesystem, but the logical block size of the underlying block device that loop's queue must match (or exceed). With the current loop code, if the backing file is opened with O_DIRECT and resides on a block device with a 512 bytes logical block size, the loop device will correctly use direct I/O. If instead the backing file happened to reside on a block device with a 4k logical block size, the loop device would silently fall back to cached mode. I think there's a benefit in the behavior being consistent independent of the block size of the backing device, and I don't see a good reason for not automatically switching loop's logical/physical queue sizes to match the backing device in this specific case.

Will send a v2.

Thanks,
Martijn

#3 lore raw

PATCH v2 1/1 loop: change queue block size to match when using DIO.

In reply to Martijn Coenen

The loop driver assumes that if the passed in fd is opened with O_DIRECT, the caller wants to use direct I/O on the loop device. However, if the underlying block device has a different block size than the loop block queue, direct I/O can't be enabled. Instead of requiring userspace to manually change the blocksize and re-enable direct I/O, just change the queue block sizes to match, as well as the io_min size.

---
v2 changes:
- Fixed commit message to say the block size must match the underlying block device, not the underlying filesystem.
- Also set physical blocksize and minimal io size correspondingly.

 drivers/block/loop.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
drivers/block/loop.c +10 -0
index ab7ca5989097a..b547182037af2 100644
@@ -994,6 +994,16 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
 	if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
 		blk_queue_write_cache(lo->lo_queue, true, false);
 
+	if (io_is_direct(lo->lo_backing_file) && inode->i_sb->s_bdev) {
+		/* In case of direct I/O, match underlying block size */
+		unsigned short bsize = bdev_logical_block_size(
+			inode->i_sb->s_bdev);
+
+		blk_queue_logical_block_size(lo->lo_queue, bsize);
+		blk_queue_physical_block_size(lo->lo_queue, bsize);
+		blk_queue_io_min(lo->lo_queue, bsize);
+	}
+
 	loop_update_rotational(lo);
 	loop_update_dio(lo);
 	set_capacity(lo->lo_disk, size);
Signature · 1 line
2.23.0.187.g17f5b7556c-goog
#4 lore raw

Hi Jens, Ming,

Do you have any thoughts about this patch?

Thanks,
Martijn

Quoted 42 lines · Martijn Coenen

The loop driver assumes that if the passed in fd is opened with O_DIRECT, the caller wants to use direct I/O on the loop device. However, if the underlying block device has a different block size than the loop block queue, direct I/O can't be enabled. Instead of requiring userspace to manually change the blocksize and re-enable direct I/O, just change the queue block sizes to match, as well as the io_min size.

---
v2 changes:
- Fixed commit message to say the block size must match the underlying block device, not the underlying filesystem.
- Also set physical blocksize and minimal io size correspondingly.

 drivers/block/loop.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
drivers/block/loop.c +10 -1
index ab7ca5989097a..b547182037af2 100644
@@ -994,6 +994,16 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
        if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
                blk_queue_write_cache(lo->lo_queue, true, false);
 
+       if (io_is_direct(lo->lo_backing_file) && inode->i_sb->s_bdev) {
+               /* In case of direct I/O, match underlying block size */
+               unsigned short bsize = bdev_logical_block_size(
+                       inode->i_sb->s_bdev);
+
+               blk_queue_logical_block_size(lo->lo_queue, bsize);
+               blk_queue_physical_block_size(lo->lo_queue, bsize);
+               blk_queue_io_min(lo->lo_queue, bsize);
+       }
+
        loop_update_rotational(lo);
        loop_update_dio(lo);
        set_capacity(lo->lo_disk, size);
--

2.23.0.187.g17f5b7556c-goog

maintainer Applied
#7 lore raw
In reply to Martijn Coenen
Quoted 6 lines · Martijn Coenen

The loop driver assumes that if the passed in fd is opened with O_DIRECT, the caller wants to use direct I/O on the loop device. However, if the underlying block device has a different block size than the loop block queue, direct I/O can't be enabled. Instead of requiring userspace to manually change the blocksize and re-enable direct I/O, just change the queue block sizes to match, as well as the io_min size.

Applied, thanks.

Signature · 1 line
Jens Axboe