Skip to contentSkip to conversation

loop: enable different physical blocksizes

PATCH Superseded Hannes Reinecke 3 participants 12 messages Oct 31, 2016 – Nov 3, 2016 Block layer

v3 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v3 cover loop: enable different physical blocksizes

Currently the loop driver just simulates 512-byte blocks. When creating bootable images for virtual machines it might be required to use a different physical blocksize (eg 4k for S/390 DASD), as the some bootloaders (like lilo or zipl for S/390) need to know the physical block addresses of the kernel and initrd.

This patchset extends the current LOOP_SET_STATUS64 ioctl to set the logical and physical blocksize by re-using the existing 'init' fields, which are currently unused.

As usual, comments and reviews are welcome.

Changes to v1:
- Move LO_FLAGS_BLOCKSIZE definition
- Reshuffle patches
Changes to v2:
- Include reviews from Ming Lei

Hannes Reinecke (4):
loop: Remove unused 'bdev' argument from loop_set_capacity
loop: Enable correct physical blocksize
loop: Add 'lo_logical_blocksize'
loop: Pass logical blocksize in 'lo_init[0]' ioctl field

 drivers/block/loop.c      | 40 +++++++++++++++++++++++++++++++++-------
 drivers/block/loop.h      |  1 +
 include/uapi/linux/loop.h |  1 +
 3 files changed, 35 insertions(+), 7 deletions(-)
Signature · 1 line
2.6.6
#1 lore raw

PATCH v3 1/4 loop: Remove unused 'bdev' argument from loop_set_capacity

---
 drivers/block/loop.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/block/loop.c +2 -2
index fa1b7a9..3008dec 100644
@@ -1298,7 +1298,7 @@ loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) {
 	return err;
 }
 
-static int loop_set_capacity(struct loop_device *lo, struct block_device *bdev)
+static int loop_set_capacity(struct loop_device *lo)
 {
 	if (unlikely(lo->lo_state != Lo_bound))
 		return -ENXIO;
@@ -1361,7 +1361,7 @@ static int lo_ioctl(struct block_device *bdev, fmode_t mode,
 	case LOOP_SET_CAPACITY:
 		err = -EPERM;
 		if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN))
-			err = loop_set_capacity(lo, bdev);
+			err = loop_set_capacity(lo);
 		break;
 	case LOOP_SET_DIRECT_IO:
 		err = -EPERM;
Signature · 1 line
2.6.6
Reviewed-by on v3 1/4
#2 lore raw

Re: [PATCH 1/4] loop: Remove unused 'bdev' argument from loop_set_capacity

Quoted 20 lines · Hannes Reinecke
---
 drivers/block/loop.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/block/loop.c +1 -1
index fa1b7a9..3008dec 100644
@@ -1298,7 +1298,7 @@ loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) {
        return err;
 }
 
-static int loop_set_capacity(struct loop_device *lo, struct block_device *bdev)
+static int loop_set_capacity(struct loop_device *lo)
 {
        if (unlikely(lo->lo_state != Lo_bound))
                return -ENXIO;

drivers/block/loop.c static int lo_ioctl(struct block_device *bdev, fmode_t mode, · line 1367

Quoted 8 lines
drivers/block/loop.c +1 -1
@@ -1361,7 +1361,7 @@ static int lo_ioctl(struct block_device *bdev, fmode_t mode,
        case LOOP_SET_CAPACITY:
                err = -EPERM;
                if ((mode & FMODE_WRITE) || capable(CAP_SYS_ADMIN))
-                       err = loop_set_capacity(lo, bdev);
+                       err = loop_set_capacity(lo);
                break;
        case LOOP_SET_DIRECT_IO:
                err = -EPERM;

thanks,
Ming Lei

#3 lore raw

PATCH v3 2/4 loop: Enable correct physical blocksize

In reply to Hannes Reinecke

When running on files the physical blocksize is actually 4k, so we should be announcing it as such. This is enabled with a new LO_FLAGS_BLOCKSIZE flag value to the existing loop_set_status ioctl.

---
 drivers/block/loop.c      | 9 ++++++++-
 include/uapi/linux/loop.h | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)
drivers/block/loop.c +8 -1
index 3008dec..ff5c874 100644
@@ -233,6 +233,8 @@ figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit)
 		lo->lo_offset = offset;
 	if (lo->lo_sizelimit != sizelimit)
 		lo->lo_sizelimit = sizelimit;
+	if (lo->lo_flags & LO_FLAGS_BLOCKSIZE)
+		blk_queue_physical_block_size(lo->lo_queue, lo->lo_blocksize);
 	set_capacity(lo->lo_disk, x);
 	bd_set_size(bdev, (loff_t)get_capacity(bdev->bd_disk) << 9);
 	/* let user-space know about the new size */
@@ -1087,6 +1089,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
 	int err;
 	struct loop_func_table *xfer;
 	kuid_t uid = current_uid();
+	int lo_flags = lo->lo_flags;
 
 	if (lo->lo_encrypt_key_size &&
 	    !uid_eq(lo->lo_key_owner, uid) &&
@@ -1116,8 +1119,12 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
 	if (err)
 		return err;
 
+	if (info->lo_flags & LO_FLAGS_BLOCKSIZE)
+		lo->lo_flags |= LO_FLAGS_BLOCKSIZE;
+
 	if (lo->lo_offset != info->lo_offset ||
-	    lo->lo_sizelimit != info->lo_sizelimit)
+	    lo->lo_sizelimit != info->lo_sizelimit ||
+	    lo->lo_flags != lo_flags)
 		if (figure_loop_size(lo, info->lo_offset, info->lo_sizelimit))
 			return -EFBIG;
 
include/uapi/linux/loop.h +1 -0
index c8125ec..2691c1c 100644
@@ -22,6 +22,7 @@ enum {
 	LO_FLAGS_AUTOCLEAR	= 4,
 	LO_FLAGS_PARTSCAN	= 8,
 	LO_FLAGS_DIRECT_IO	= 16,
+	LO_FLAGS_BLOCKSIZE	= 32,
 };
 
 #include <asm/posix_types.h>	/* for __kernel_old_dev_t */
Signature · 1 line
2.6.6
Reviewed-by on v3 2/4
#4 lore raw

Re: [PATCH 2/4] loop: Enable correct physical blocksize

Quoted 1 line · Hannes Reinecke

When running on files the physical blocksize is actually 4k,

Is it? Independent of that sentence the patch looks fine:

#5 lore raw

PATCH v3 3/4 loop: Add 'lo_logical_blocksize'

In reply to Hannes Reinecke

Add a new field 'lo_logical_blocksize' to hold the logical blocksize of the loop device.

---
 drivers/block/loop.c | 9 +++++++--
 drivers/block/loop.h | 1 +
 2 files changed, 8 insertions(+), 2 deletions(-)
drivers/block/loop.c +7 -2
index ff5c874..a863667 100644
@@ -233,8 +233,11 @@ figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit)
 		lo->lo_offset = offset;
 	if (lo->lo_sizelimit != sizelimit)
 		lo->lo_sizelimit = sizelimit;
-	if (lo->lo_flags & LO_FLAGS_BLOCKSIZE)
+	if (lo->lo_flags & LO_FLAGS_BLOCKSIZE) {
 		blk_queue_physical_block_size(lo->lo_queue, lo->lo_blocksize);
+		blk_queue_logical_block_size(lo->lo_queue,
+					     lo->lo_logical_blocksize);
+	}
 	set_capacity(lo->lo_disk, x);
 	bd_set_size(bdev, (loff_t)get_capacity(bdev->bd_disk) << 9);
 	/* let user-space know about the new size */
@@ -816,6 +819,7 @@ static void loop_config_discard(struct loop_device *lo)
 	struct file *file = lo->lo_backing_file;
 	struct inode *inode = file->f_mapping->host;
 	struct request_queue *q = lo->lo_queue;
+	int lo_bits = blksize_bits(lo->lo_logical_blocksize);
 
 	/*
 	 * We use punch hole to reclaim the free space used by the
@@ -835,7 +839,7 @@ static void loop_config_discard(struct loop_device *lo)
 
 	q->limits.discard_granularity = inode->i_sb->s_blocksize;
 	q->limits.discard_alignment = 0;
-	blk_queue_max_discard_sectors(q, UINT_MAX >> 9);
+	blk_queue_max_discard_sectors(q, UINT_MAX >> lo_bits);
 	q->limits.discard_zeroes_data = 1;
 	queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
 }
@@ -924,6 +928,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
 
 	lo->use_dio = false;
 	lo->lo_blocksize = lo_blocksize;
+	lo->lo_logical_blocksize = 512;
 	lo->lo_device = bdev;
 	lo->lo_flags = lo_flags;
 	lo->lo_backing_file = file;
drivers/block/loop.h +1 -0
index fb2237c..579f2f7 100644
@@ -49,6 +49,7 @@ struct loop_device {
 	struct file *	lo_backing_file;
 	struct block_device *lo_device;
 	unsigned	lo_blocksize;
+	unsigned	lo_logical_blocksize;
 	void		*key_data; 
 
 	gfp_t		old_gfp_mask;
Signature · 1 line
2.6.6
#6 lore raw

Re: [PATCH 3/4] loop: Add 'lo_logical_blocksize'

Quoted 2 lines · Hannes Reinecke

Add a new field 'lo_logical_blocksize' to hold the logical blocksize of the loop device.

Why do we use the same flag for both block sizes? If there is a good reason for that it should be documented and both should be in the same patch.

#7 lore raw

Re: [PATCH 3/4] loop: Add 'lo_logical_blocksize'

Quoted 8 lines · Christoph Hellwig
Quoted 2 lines · Hannes Reinecke

Add a new field 'lo_logical_blocksize' to hold the logical blocksize of the loop device.

Why do we use the same flag for both block sizes? If there is a good reason for that it should be documented and both should be in the same patch.

_Actually_ the flag enables you to set the logical blocksize.
However, if you want to set the logical blocksize you also have to set a matching physical blocksize.
And the physical blocksize itself isn't settable, rather taken from the underlying device/filesystem/whatever.
So the flag itself does not have a dual purpose, it's just out of necessity that you have to set the physical blocksize if you want to change the logical blocksize.

And I got pushback when I proposed to set the physical blocksize always, so I made it dependent on the LO_BLOCKSIZE flag, too.

Cheers,

Hannes

Signature · 4 lines
Dr. Hannes Reinecke		      zSeries & Storage
[email protected]			      +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
#8 lore raw

PATCH v3 4/4 loop: Pass logical blocksize in 'lo_init[0]' ioctl field

In reply to Hannes Reinecke

The current LOOP_SET_STATUS64 ioctl has two unused fields 'init[2]', which can be used in conjunction with the LO_FLAGS_BLOCKSIZE flag to pass in the new logical blocksize.

---
 drivers/block/loop.c | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)
drivers/block/loop.c +19 -5
index a863667..9ad56bf 100644
@@ -221,7 +221,8 @@ static void __loop_update_dio(struct loop_device *lo, bool dio)
 }
 
 static int
-figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit)
+figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit,
+		 loff_t logical_blocksize)
 {
 	loff_t size = get_size(offset, sizelimit, lo->lo_backing_file);
 	sector_t x = (sector_t)size;
@@ -234,6 +235,7 @@ figure_loop_size(struct loop_device *lo, loff_t offset, loff_t sizelimit)
 	if (lo->lo_sizelimit != sizelimit)
 		lo->lo_sizelimit = sizelimit;
 	if (lo->lo_flags & LO_FLAGS_BLOCKSIZE) {
+		lo->lo_logical_blocksize = logical_blocksize;
 		blk_queue_physical_block_size(lo->lo_queue, lo->lo_blocksize);
 		blk_queue_logical_block_size(lo->lo_queue,
 					     lo->lo_logical_blocksize);
@@ -1124,13 +1126,24 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
 	if (err)
 		return err;
 
-	if (info->lo_flags & LO_FLAGS_BLOCKSIZE)
+	if (info->lo_flags & LO_FLAGS_BLOCKSIZE) {
 		lo->lo_flags |= LO_FLAGS_BLOCKSIZE;
+		if ((info->lo_init[0] != 512) &&
+		    (info->lo_init[0] != 1024) &&
+		    (info->lo_init[0] != 2048) &&
+		    (info->lo_init[0] != 4096))
+			return -EINVAL;
+		if (info->lo_init[0] > lo->lo_blocksize)
+			return -EINVAL;
+	}
 
 	if (lo->lo_offset != info->lo_offset ||
 	    lo->lo_sizelimit != info->lo_sizelimit ||
-	    lo->lo_flags != lo_flags)
-		if (figure_loop_size(lo, info->lo_offset, info->lo_sizelimit))
+	    lo->lo_flags != lo_flags ||
+	    ((lo->lo_flags & LO_FLAGS_BLOCKSIZE) &&
+	     (lo->lo_logical_blocksize != info->lo_init[0])))
+		if (figure_loop_size(lo, info->lo_offset, info->lo_sizelimit,
+				     info->lo_init[0]))
 			return -EFBIG;
 
 	loop_config_discard(lo);
@@ -1315,7 +1328,8 @@ static int loop_set_capacity(struct loop_device *lo)
 	if (unlikely(lo->lo_state != Lo_bound))
 		return -ENXIO;
 
-	return figure_loop_size(lo, lo->lo_offset, lo->lo_sizelimit);
+	return figure_loop_size(lo, lo->lo_offset, lo->lo_sizelimit,
+				lo->lo_logical_blocksize);
 }
 
 static int loop_set_dio(struct loop_device *lo, unsigned long arg)
Signature · 1 line
2.6.6
#9 lore raw

Re: [PATCH 4/4] loop: Pass logical blocksize in 'lo_init[0]' ioctl field

Quoted 3 lines · Hannes Reinecke

The current LOOP_SET_STATUS64 ioctl has two unused fields 'init[2]', which can be used in conjunction with the LO_FLAGS_BLOCKSIZE flag to pass in the new logical blocksize.

Can we give them sane field names while at it? Also I see now reason not to merge this with the previous two patches.

#10 lore raw

Re: [PATCH 4/4] loop: Pass logical blocksize in 'lo_init[0]' ioctl field

Quoted 8 lines · Christoph Hellwig
Quoted 3 lines · Hannes Reinecke

The current LOOP_SET_STATUS64 ioctl has two unused fields 'init[2]', which can be used in conjunction with the LO_FLAGS_BLOCKSIZE flag to pass in the new logical blocksize.

Can we give them sane field names while at it? Also I see now reason not to merge this with the previous two patches.

Sure I can rename it.
As for merging, I don't really care.

So for the next round I'll be merging them all together.

Cheers,

Hannes

Signature · 4 lines
Dr. Hannes Reinecke		      zSeries & Storage
[email protected]			      +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)
#11 lore raw

Re: [PATCH 4/4] loop: Pass logical blocksize in 'lo_init[0]' ioctl field

In reply to Christoph Hellwig
Quoted 8 lines · Christoph Hellwig
Quoted 3 lines · Hannes Reinecke

The current LOOP_SET_STATUS64 ioctl has two unused fields 'init[2]', which can be used in conjunction with the LO_FLAGS_BLOCKSIZE flag to pass in the new logical blocksize.

Can we give them sane field names while at it? Also I see now reason not to merge this with the previous two patches.

I'd rather not change the name; it's part of the exported ioctl interface, and changing would mean to change the ioctl interface. Which would make quite some user-space programs barf.

Cheers,

Hannes

Signature · 4 lines
Dr. Hannes Reinecke		      zSeries & Storage
[email protected]			      +49 911 74053 688
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg
GF: J. Hawn, J. Guild, F. Imendörffer, HRB 16746 (AG Nürnberg)