loop: enable different logical blocksizes
v6 cover loop: enable different logical 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.
With this patchset the loop driver will export the logical and physical blocksize and the current LOOP_SET_STATUS64 ioctl is extended to set the logical 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
Changes to v3:
- Include reviews from Christoph
- Merge patches
Changes to v4:
- Add LO_INFO_BLOCKSIZE definition
Changes to v5:
- Rediff to latest upstream
Hannes Reinecke (2):
loop: Remove unused 'bdev' argument from loop_set_capacity
loop: support 4k physical blocksize
drivers/block/loop.c | 40 +++++++++++++++++++++++++++++++++------- drivers/block/loop.h | 1 + include/uapi/linux/loop.h | 3 +++ 3 files changed, 37 insertions(+), 7 deletions(-)
Signature · 1 line
1.8.5.6
PATCH v6 1/2 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
@@ -1307,7 +1307,7 @@ static int loop_clr_fd(struct loop_device *lo)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 ;
@@ -1370,7 +1370,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
1.8.5.6
Re: [PATCHv6 1/2] loop: Remove unused 'bdev' argument from loop_set_capacity
Quoted 20 lines · Hannes Reinecke
Signed-off-by Hannes Reinecke <[email protected]>Reviewed-by Christoph Hellwig <[email protected]>--- drivers/block/loop.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)drivers/block/loop.c +1
-1@@ -1307,7 +1307,7 @@ static int loop_clr_fd(struct loop_device *lo)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 1376
Quoted 8 lines
drivers/block/loop.c +1
-1@@ -1370,7 +1370,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
PATCH v6 2/2 loop: support 4k physical blocksize
In reply to Hannes ReineckeWhen generating bootable VM images certain systems (most notably s390x) require devices with 4k blocksize. This patch implements a new flag 'LO_FLAGS_BLOCKSIZE' which will set the physical blocksize to that of the underlying device, and allow to change the logical blocksize for up to the physical blocksize.
--- drivers/block/loop.c | 36 +++++++++++++++++++++++++++++++----- drivers/block/loop.h | 1 + include/uapi/linux/loop.h | 3 +++ 3 files changed, 35 insertions(+), 5 deletions(-)
drivers/block/loop.c +31 -5
@@ -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;
@@ -233,6 +234,12 @@ static void __loop_update_dio(struct loop_device *lo, bool dio) 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 */
@@ -814,6 +821,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
@@ -833,7 +841,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); }
@@ -922,6 +930,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;
@@ -1087,6 +1096,7 @@ static int loop_clr_fd(struct loop_device *lo)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) &&
@@ -1119,9 +1129,24 @@ static int loop_clr_fd(struct loop_device *lo)if (err) goto exit; +if (info->lo_flags &LO_FLAGS_BLOCKSIZE ) { + lo->lo_flags |=LO_FLAGS_BLOCKSIZE ; +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 ; + } +if (lo->lo_offset != info->lo_offset || - lo->lo_sizelimit != info->lo_sizelimit) -if (figure_loop_size (lo, info->lo_offset, info->lo_sizelimit)) { + 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, + info->lo_init[0 ])) err = -EFBIG ; goto exit; }
@@ -1312,7 +1337,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)
drivers/block/loop.h +1 -0
@@ -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;
include/uapi/linux/loop.h +3 -0
@@ -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 */
@@ -59,6 +60,8 @@ struct loop_info64 {__u64 lo_init[2 ]; }; +#define LO_INFO_BLOCKSIZE (l) (l)->lo_init[0] +/* * Loop filter types */
Signature · 1 line
1.8.5.6
Re: [PATCHv6 2/2] loop: support 4k physical blocksize
Quoted 5 lines · Hannes Reinecke
When generating bootable VM images certain systems (most notably s390x) require devices with 4k blocksize. This patch implements a new flag '
LO_FLAGS_BLOCKSIZE' which will set the physical blocksize to that of the underlying device, and allow to change the logical blocksize for up to the physical blocksize.
Actually this UAPI flag is only for setting logical block size.
Quoted 23 lines
Signed-off-by Hannes Reinecke <[email protected]>--- drivers/block/loop.c | 36 +++++++++++++++++++++++++++++++----- drivers/block/loop.h | 1 + include/uapi/linux/loop.h | 3 +++ 3 files changed, 35 insertions(+), 5 deletions(-)drivers/block/loop.c +2
-1@@ -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;
drivers/block/loop.c static void __loop_update_dio(struct loop_device *lo, bool dio) · line 242
Quoted 9 lines
drivers/block/loop.c +6
-0@@ -233,6 +234,12 @@ static void __loop_update_dio(struct loop_device *lo, bool dio) 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); + }
We can move setting physical block size into loop_set_fd(), and set 512 bytes as default logical block size in loop_set_fd() too.
Quoted 21 lines
drivers/block/loop.c +2
-1set_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 */ @@ -814,6 +821,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 @@ -833,7 +841,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); }
drivers/block/loop.c static int loop_set_fd(struct loop_device *lo, fmode_t mode, · line 933
Quoted 4 lines
drivers/block/loop.c +1
-0@@ -922,6 +930,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 ;
It isn't enough to just this local vaiable as 512 here, since the last logical block size is still kept in queue's setting.
Quoted 84 lines
drivers/block/loop.c +20
-3lo->lo_device = bdev; lo->lo_flags = lo_flags; lo->lo_backing_file = file;@@ -1087,6 +1096,7 @@ static int loop_clr_fd(struct loop_device *lo)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) &&@@ -1119,9 +1129,24 @@ static int loop_clr_fd(struct loop_device *lo)if (err) goto exit; +if (info->lo_flags &LO_FLAGS_BLOCKSIZE ) { + lo->lo_flags |=LO_FLAGS_BLOCKSIZE ; +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 ; + } +if (lo->lo_offset != info->lo_offset || - lo->lo_sizelimit != info->lo_sizelimit) -if (figure_loop_size (lo, info->lo_offset, info->lo_sizelimit)) { + 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, + info->lo_init[0 ])) err = -EFBIG ; goto exit; }@@ -1312,7 +1337,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)drivers/block/loop.h +1
-0@@ -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;include/uapi/linux/loop.h +3
-0@@ -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 */ @@ -59,6 +60,8 @@ struct loop_info64 {__u64 lo_init[2 ]; }; +#define LO_INFO_BLOCKSIZE (l) (l)->lo_init[0] +/* * Loop filter types */ Signature · 1 line
1.8.5.6
Signature · 1 line
Ming
Re: [PATCHv6 2/2] loop: support 4k physical blocksize
Quoted 9 lines · Ming Lei
Quoted 5 lines · Hannes Reinecke
When generating bootable VM images certain systems (most notably s390x) require devices with 4k blocksize. This patch implements a new flag '
LO_FLAGS_BLOCKSIZE' which will set the physical blocksize to that of the underlying device, and allow to change the logical blocksize for up to the physical blocksize.Actually this UAPI flag is only for setting logical block size.
Hmm? No, we're setting the physical blocksize, too. Or am I missing something?
Quoted 27 lines
Quoted 27 lines
Signed-off-by Hannes Reinecke <[email protected]>--- drivers/block/loop.c | 36 +++++++++++++++++++++++++++++++----- drivers/block/loop.h | 1 + include/uapi/linux/loop.h | 3 +++ 3 files changed, 35 insertions(+), 5 deletions(-)drivers/block/loop.c +3
-1@@ -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;@@ -233,6 +234,12 @@ static void __loop_update_dio(struct loop_device *lo, bool dio) lo->lo_offset = offset;if (lo->lo_sizelimit != sizelimit) lo->lo_sizelimit = sizelimit; +if (lo->lo_flags &LO_FLAGS_BLOCKSIZE ) {
Quoted 9 lines
drivers/block/loop.c static void __loop_update_dio(struct loop_device *lo, bool dio) · line 242
Quoted 5 lines
drivers/block/loop.c +5
-0+ 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); + }We can move setting physical block size into
loop_set_fd(), and set 512 bytes as default logical block size inloop_set_fd()too.
Okay.
Quoted 22 lines
Quoted 22 lines
drivers/block/loop.c +2
-1set_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 */ @@ -814,6 +821,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 @@ -833,7 +841,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); }@@ -922,6 +930,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
Quoted 7 lines
drivers/block/loop.c static int loop_set_fd(struct loop_device *lo, fmode_t mode, · line 933
Quoted 3 lines
drivers/block/loop.c +1
-0lo->use_dio = false; lo->lo_blocksize = lo_blocksize; + lo->lo_logical_blocksize =512 ;It isn't enough to just this local vaiable as 512 here, since the last logical block size is still kept in queue's setting.
Right. Will be updating the queue setting, too.
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: [PATCHv6 2/2] loop: support 4k physical blocksize
Quoted 49 lines · Hannes Reinecke
Quoted 9 lines · Ming Lei
Quoted 5 lines · Hannes Reinecke
When generating bootable VM images certain systems (most notably s390x) require devices with 4k blocksize. This patch implements a new flag '
LO_FLAGS_BLOCKSIZE' which will set the physical blocksize to that of the underlying device, and allow to change the logical blocksize for up to the physical blocksize.Actually this UAPI flag is only for setting logical block size.
Hmm? No, we're setting the physical blocksize, too. Or am I missing something?
Quoted 27 lines
Quoted 27 lines
Signed-off-by Hannes Reinecke <[email protected]>--- drivers/block/loop.c | 36 +++++++++++++++++++++++++++++++----- drivers/block/loop.h | 1 + include/uapi/linux/loop.h | 3 +++ 3 files changed, 35 insertions(+), 5 deletions(-)drivers/block/loop.c +3
-1@@ -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;@@ -233,6 +234,12 @@ static void __loop_update_dio(struct loop_device *lo, bool dio) lo->lo_offset = offset;if (lo->lo_sizelimit != sizelimit) lo->lo_sizelimit = sizelimit; +if (lo->lo_flags &LO_FLAGS_BLOCKSIZE ) {Quoted 9 lines
drivers/block/loop.c static void __loop_update_dio(struct loop_device *lo, bool dio) · line 242
Quoted 5 lines
drivers/block/loop.c +5
-0+ 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); + }We can move setting physical block size into
loop_set_fd(), and set 512 bytes as default logical block size inloop_set_fd()too.
Quoted 2 lines
Okay.
After thinking about it some more I'm not sure if I agree with that reasoning.
One of the goals of this patchset is to keep compability with existing installations.
If we move setting the physical blocksize into loop_set_fd() (which needs to be called before loop_set_status()) the physical blocksize would always be set.
Which would induce a user-visible change.
Hence I've formulated my patch to _not_ change the default setup if the new flag isn't set.
If this is of no concern, however, I can easily modify the patch to always set the physical blocksize; in fact, that's what I did originally, but that was deemed bad style.
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: [PATCHv6 2/2] loop: support 4k physical blocksize
Quoted 62 lines · Hannes Reinecke
Quoted 49 lines · Hannes Reinecke
Quoted 9 lines · Ming Lei
Quoted 5 lines · Hannes Reinecke
When generating bootable VM images certain systems (most notably s390x) require devices with 4k blocksize. This patch implements a new flag '
LO_FLAGS_BLOCKSIZE' which will set the physical blocksize to that of the underlying device, and allow to change the logical blocksize for up to the physical blocksize.Actually this UAPI flag is only for setting logical block size.
Hmm? No, we're setting the physical blocksize, too. Or am I missing something?
Quoted 27 lines
Quoted 27 lines
Signed-off-by Hannes Reinecke <[email protected]>--- drivers/block/loop.c | 36 +++++++++++++++++++++++++++++++----- drivers/block/loop.h | 1 + include/uapi/linux/loop.h | 3 +++ 3 files changed, 35 insertions(+), 5 deletions(-)drivers/block/loop.c +3
-1@@ -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;@@ -233,6 +234,12 @@ static void __loop_update_dio(struct loop_device *lo, bool dio) lo->lo_offset = offset;if (lo->lo_sizelimit != sizelimit) lo->lo_sizelimit = sizelimit; +if (lo->lo_flags &LO_FLAGS_BLOCKSIZE ) {Quoted 9 lines
drivers/block/loop.c static void __loop_update_dio(struct loop_device *lo, bool dio) · line 242
Quoted 5 lines
drivers/block/loop.c +5
-0+ 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); + }We can move setting physical block size into
loop_set_fd(), and set 512 bytes as default logical block size inloop_set_fd()too.Quoted 2 lines
Okay.
After thinking about it some more I'm not sure if I agree with that reasoning.
One of the goals of this patchset is to keep compability with existing installations.
If we move setting the physical blocksize intoloop_set_fd()(which needs to be called beforeloop_set_status()) the physical blocksize would always be set.
Which would induce a user-visible change.
Quoted 2 lines
Hence I've formulated my patch to _not_ change the default setup if the new flag isn't set.
OK, better to not break current users, :-)
Thanks,
Ming