loop: LO_FLAGS_BLOCKSIZE fixes
v2 cover loop: LO_FLAGS_BLOCKSIZE fixes
From: Omar Sandoval <[email protected]>
Patches 1 and 3 are from the original series.
Patch 2 gets rid of the redundant struct loop_device.lo_logical_blocksize in favor of using the queue's own logical_block_size. Karel, I decided against adding another sysfs entry since it will always be the same as queue/logical_block_size, is that alright with you?
Omar Sandoval (3):
loop: fix hang if LOOP_SET_STATUS gets invalid blocksize or encrypt
type
loop: use queue limit instead of private lo_logical_blocksize
loop: always return block size in LOOP_GET_STATUS
drivers/block/loop.c | 71 ++++++++++++++++++++++++++-------------------------- drivers/block/loop.h | 1 - 2 files changed, 36 insertions(+), 36 deletions(-)
Signature · 1 line
2.14.1
PATCH v2 1/3 loop: fix hang if LOOP_SET_STATUS gets invalid blocksize or encrypt type
From: Omar Sandoval <[email protected]>
In both of these error cases, we need to make sure to unfreeze the queue before we return.
--- drivers/block/loop.c | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-)
drivers/block/loop.c +16 -8
@@ -1125,11 +1125,15 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)if (info->lo_encrypt_type) {unsigned int type = info->lo_encrypt_type; -if (type >=MAX_LO_CRYPT ) -return -EINVAL ; +if (type >=MAX_LO_CRYPT ) { + err = -EINVAL ; + goto exit; + } xfer = xfer_funcs[type]; -if (xfer ==NULL ) -return -EINVAL ; +if (xfer ==NULL ) { + err = -EINVAL ; + goto exit; + } }else xfer =NULL ;
@@ -1144,10 +1148,14 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)if (LO_INFO_BLOCKSIZE (info) !=512 &&LO_INFO_BLOCKSIZE (info) !=1024 &&LO_INFO_BLOCKSIZE (info) !=2048 && -LO_INFO_BLOCKSIZE (info) !=4096 ) -return -EINVAL ; -if (LO_INFO_BLOCKSIZE (info) > lo->lo_blocksize) -return -EINVAL ; +LO_INFO_BLOCKSIZE (info) !=4096 ) { + err = -EINVAL ; + goto exit; + } +if (LO_INFO_BLOCKSIZE (info) > lo->lo_blocksize) { + err = -EINVAL ; + goto exit; + } } if (lo->lo_offset != info->lo_offset ||
Signature · 1 line
2.14.1
PATCH v2 2/3 loop: use queue limit instead of private lo_logical_blocksize
In reply to Omar SandovalFrom: Omar Sandoval <[email protected]>
There's no reason to track this separately; just use the logical_block_size queue limit.
--- drivers/block/loop.c | 44 ++++++++++++++++++-------------------------- drivers/block/loop.h | 1 - 2 files changed, 18 insertions(+), 27 deletions(-)
drivers/block/loop.c +18 -26
@@ -221,8 +221,7 @@ 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, -loff_t logical_blocksize) +figure_loop_size (struct loop_device *lo,loff_t offset,loff_t sizelimit) {loff_t size =get_size (offset, sizelimit, lo->lo_backing_file);sector_t x = (sector_t )size;
@@ -234,12 +233,6 @@ 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 ) { - 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); - }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 */
@@ -820,7 +813,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 =9 ; +int lo_bits =blksize_bits (queue_logical_block_size (q));/* * We use punch hole to reclaim the free space used by the
@@ -840,8 +833,6 @@ static void loop_config_discard(struct loop_device *lo) q->limits.discard_granularity = inode->i_sb->s_blocksize; q->limits.discard_alignment =0 ; -if (lo->lo_flags &LO_FLAGS_BLOCKSIZE ) - lo_bits =blksize_bits (lo->lo_logical_blocksize);blk_queue_max_discard_sectors (q,UINT_MAX >> lo_bits);blk_queue_max_write_zeroes_sectors (q,UINT_MAX >> lo_bits);
@@ -938,7 +929,6 @@ 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;
@@ -950,6 +940,9 @@ 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); +blk_queue_logical_block_size (lo->lo_queue,512 ); +blk_queue_physical_block_size (lo->lo_queue,512 ); +blk_queue_io_min (lo->lo_queue,512 );loop_update_dio (lo);set_capacity (lo->lo_disk, size);
@@ -1137,14 +1130,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info) }else xfer =NULL ; - err =loop_init_xfer (lo, xfer, info); -if (err) - goto exit; -if (info->lo_flags &LO_FLAGS_BLOCKSIZE ) { -if (!(lo->lo_flags &LO_FLAGS_BLOCKSIZE )) - lo->lo_logical_blocksize =512 ; - lo->lo_flags |=LO_FLAGS_BLOCKSIZE ; if (LO_INFO_BLOCKSIZE(info) != 512 && LO_INFO_BLOCKSIZE(info) != 1024 && LO_INFO_BLOCKSIZE(info) != 2048 &&
@@ -1158,18 +1144,25 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info) } } + err =loop_init_xfer (lo, xfer, info); +if (err) + goto exit; +if (lo->lo_offset != info->lo_offset || lo->lo_sizelimit != info->lo_sizelimit || - lo->lo_flags != lo_flags || - ((lo->lo_flags &LO_FLAGS_BLOCKSIZE ) && - lo->lo_logical_blocksize !=LO_INFO_BLOCKSIZE (info))) { -if (figure_loop_size (lo, info->lo_offset, info->lo_sizelimit, -LO_INFO_BLOCKSIZE (info))) { + lo->lo_flags != lo_flags) { +if (figure_loop_size (lo, info->lo_offset, info->lo_sizelimit)) { err = -EFBIG ; goto exit; } } +if (info->lo_flags &LO_FLAGS_BLOCKSIZE ) { +blk_queue_logical_block_size (lo->lo_queue,LO_INFO_BLOCKSIZE (info)); +blk_queue_physical_block_size (lo->lo_queue,LO_INFO_BLOCKSIZE (info)); +blk_queue_io_min (lo->lo_queue,LO_INFO_BLOCKSIZE (info)); + } +loop_config_discard (lo);memcpy (lo->lo_file_name, info->lo_file_name,LO_NAME_SIZE );
@@ -1356,8 +1349,7 @@ 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, - lo->lo_logical_blocksize); +return figure_loop_size (lo, lo->lo_offset, lo->lo_sizelimit); }static int loop_set_dio (struct loop_device *lo,unsigned long arg)
drivers/block/loop.h +0 -1
@@ -49,7 +49,6 @@ 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.14.1
PATCH v2 3/3 loop: always return block size in LOOP_GET_STATUS
In reply to Omar SandovalFrom: Omar Sandoval <[email protected]>
When I was writing a test for the new loop device block size functionality, I noticed a couple of issues with how LOOP_GET_STATUS handles the block size:
- lo_init[0] is never filled in with the logical block size we previously set
- lo_flags returned from LOOP_GET_STATUS will have LO_FLAGS_BLOCKSIZE set if we previously called LOOP_SET_STATUS with LO_FLAGS_BLOCKSIZE set, which doesn't really mean anything
Instead, for LOOP_GET_STATUS, let's always fill in lo_init[0] and set the LO_FLAGS_BLOCKSIZE flag to indicate we support it.
--- drivers/block/loop.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/block/loop.c +2 -1
@@ -1224,7 +1224,7 @@ loop_get_status(struct loop_device *lo, struct loop_info64 *info) info->lo_rdevice =huge_encode_dev (lo->lo_device ? stat.rdev : stat.dev); info->lo_offset = lo->lo_offset; info->lo_sizelimit = lo->lo_sizelimit; - info->lo_flags = lo->lo_flags; + info->lo_flags = lo->lo_flags |LO_FLAGS_BLOCKSIZE ;memcpy (info->lo_file_name, lo->lo_file_name,LO_NAME_SIZE );memcpy (info->lo_crypt_name, lo->lo_crypt_name,LO_NAME_SIZE ); info->lo_encrypt_type =
@@ -1234,6 +1234,7 @@ loop_get_status(struct loop_device *lo, struct loop_info64 *info)memcpy (info->lo_encrypt_key, lo->lo_encrypt_key, lo->lo_encrypt_key_size); } +LO_INFO_BLOCKSIZE (info) =queue_logical_block_size (lo->lo_queue);return 0 ; }
Signature · 1 line
2.14.1
Re: [PATCH v2 2/3] loop: use queue limit instead of private lo_logical_blocksize
In reply to Omar SandovalQuoted 11 lines · Omar Sandoval
From: Omar Sandoval <[email protected]>
There's no reason to track this separately; just use the
logical_block_sizequeue limit.Signed-off-by Omar Sandoval <[email protected]>--- drivers/block/loop.c | 44 ++++++++++++++++++-------------------------- drivers/block/loop.h | 1 - 2 files changed, 18 insertions(+), 27 deletions(-)
Curiously enough, this is what I attempted initially. But that got shut down due to incompability. In the hope that you'll succeed:
Cheers,
Hannes
Signature · 5 lines
Dr. Hannes Reinecke Teamlead Storage & Networking [email protected] +49 911 74053 688 SUSE LINUX GmbH, Maxfeldstr. 5, 90409 Nürnberg GF: F. Imendörffer, J. Smithard, J. Guild, D. Upmanyu, G. Norton HRB 21284 (AG Nürnberg)
Re: [PATCH v2 3/3] loop: always return block size in LOOP_GET_STATUS
In reply to Omar SandovalQuoted 35 lines · Omar Sandoval
From: Omar Sandoval <[email protected]>
When I was writing a test for the new loop device block size functionality, I noticed a couple of issues with how
LOOP_GET_STATUShandles the block size:- lo_init[0] is never filled in with the logical block size we previously set
-lo_flagsreturned fromLOOP_GET_STATUSwill haveLO_FLAGS_BLOCKSIZEset if we previously calledLOOP_SET_STATUSwithLO_FLAGS_BLOCKSIZEset, which doesn't really mean anythingInstead, for
LOOP_GET_STATUS, let's always fill in lo_init[0] and set theLO_FLAGS_BLOCKSIZEflag to indicate we support it.Signed-off-by Omar Sandoval <[email protected]>--- drivers/block/loop.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)drivers/block/loop.c +1
-1@@ -1224,7 +1224,7 @@ loop_get_status(struct loop_device *lo, struct loop_info64 *info) info->lo_rdevice =huge_encode_dev (lo->lo_device ? stat.rdev : stat.dev); info->lo_offset = lo->lo_offset; info->lo_sizelimit = lo->lo_sizelimit; - info->lo_flags = lo->lo_flags; + info->lo_flags = lo->lo_flags |LO_FLAGS_BLOCKSIZE ;memcpy (info->lo_file_name, lo->lo_file_name,LO_NAME_SIZE );memcpy (info->lo_crypt_name, lo->lo_crypt_name,LO_NAME_SIZE ); info->lo_encrypt_type =
drivers/block/loop.c loop_get_status(struct loop_device *lo, struct loop_info64 *info) · line 1240
Quoted 7 lines
drivers/block/loop.c +1
-0@@ -1234,6 +1234,7 @@ loop_get_status(struct loop_device *lo, struct loop_info64 *info)memcpy (info->lo_encrypt_key, lo->lo_encrypt_key, lo->lo_encrypt_key_size); } +LO_INFO_BLOCKSIZE (info) =queue_logical_block_size (lo->lo_queue);return 0 ; }
Cheers,
Hannes
Signature · 5 lines
Dr. Hannes Reinecke Teamlead Storage & Networking [email protected] +49 911 74053 688 SUSE LINUX GmbH, Maxfeldstr. 5, 90409 Nürnberg GF: F. Imendörffer, J. Smithard, J. Guild, D. Upmanyu, G. Norton HRB 21284 (AG Nürnberg)
Re: [PATCH v2 2/3] loop: use queue limit instead of private lo_logical_blocksize
In reply to Hannes ReineckeQuoted 13 lines · Hannes Reinecke
Quoted 11 lines · Omar Sandoval
From: Omar Sandoval <[email protected]>
There's no reason to track this separately; just use the
logical_block_sizequeue limit.Signed-off-by Omar Sandoval <[email protected]>--- drivers/block/loop.c | 44 ++++++++++++++++++-------------------------- drivers/block/loop.h | 1 - 2 files changed, 18 insertions(+), 27 deletions(-)
Quoted 3 lines
Curiously enough, this is what I attempted initially. But that got shut down due to incompability. In the hope that you'll succeed:
Is that thread archived anywhere? I don't see how this would be a compatability problem, it doesn't change the behavior if you're not using the new option, and if you are using the new option then there's no compatability to speak of.
Quoted 1 line
Reviewed-by Hannes Reinecke <[email protected]>
Thanks!
Quoted 9 lines · Omar Sandoval
From: Omar Sandoval <[email protected]>
Patches 1 and 3 are from the original series.
Patch 2 gets rid of the redundant struct loop_device.lo_logical_blocksize in favor of using the queue's own
logical_block_size. Karel, I decided against adding another sysfs entry since it will always be the same as queue/logical_block_size, is that alright with you?
Quoted 5 lines
Omar Sandoval (3):
loop: fix hang ifLOOP_SET_STATUSgets invalid blocksize or encrypt
type
loop: use queue limit instead of privatelo_logical_blocksize
loop: always return block size inLOOP_GET_STATUS
I tested these with cryptsetup & loop mapping with added block size setting and it fixes loop problems I see in 4.13.
I think all these patches should go to 4.13.
Thanks!
Milan