[PATCH v2 0/2] enable sector size > PAGE_SIZE for scsi

[PATCH v2 0/2] enable sector size > PAGE_SIZE for scsi

[sw.prabhu6]

From: Swarna Prabhu <sw.prabhu6@gmail.com>

Hi All,

This is v2 series sent based on the feedback received on v1 [1] and RFC
series. This patchset enables sector sizes > PAGE_SIZE for
sd driver and scsi_debug driver since block layer can support block
size > PAGE_SIZE. There was one issue with write_same16 and write_same10
command, which is fixed as a part of the series.

Changes since v1:
 - Retain the single page mempool for the regular devices.
 - Initialize a large page mempool at 'sd_probe' when the first device with
   sector size > 4k is detected for sd driver with ensuring atomicity.
 - Safe destruction of the large page mempool in 'sd_probe' if the device
   fails at probe after the mempool is successfully created.
 - Safe destruction of the large page mempool in 'sd_remove' when the last
   device with sector size > PAGE_SIZE is detached from the system.
 - Added a check in 'sd_set_special_bvec' to use the correct mempool for
   allocation based on the sector size of the device.
 - Added a check in 'sd_uninit_command' to use the correct mempool for
   freeing based on the sector size of the device.
 - Added check to destroy large page mempool if it exists while exiting
   sd driver.
 - Slightly modified the git commit message to update the above changes
   for scsi sd driver fix patch.

Thanks to Damien for feedback on the v1 series.

Testing:
 -Test suite: xfs and generic from fstest + QEMU emulated block
    device(scsi and nvme)
  - fstest Config for patched xfs 16k block size [xfs_reflink_16k_scsi]
    TEST_DEV=/dev/sda
    SCRATCH_DEV_POOL="/dev/sdb"
    MKFS_OPTIONS='-f -m reflink=1,rmapbt=1, -i sparse=1, -b size=16384,
    -s size=16384'
  - Generic test results
    Baseline: 6.19-rc8 kernel + nvme 16k logical block size
    Patched: 6.19-rc8 kernel + scsi 16k logical block size
    No regressions introduced by the patch.
  - XFS tests results
    Baseline: 6.19-rc8 kernel + nvme 16k logical block size
    Patched: 6.19-rc8 kernel + scsi 16k logical block size
    No regressions introduced by the patch
  - Blktests results
    scsi and block layer tests with 16k logical block size.
    Baseline: vanilla kernel + scsi 4k
    No regressions seen by the patch.

Link to v1: https://lore.kernel.org/all/20251210014136.2549405-1-sw.prabhu6@gmail.com/ [1]

Swarna Prabhu (2):
  scsi: sd: fix write_same(16/10) to enable sector size > PAGE_SIZE
  scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

 drivers/scsi/scsi_debug.c |  8 +---
 drivers/scsi/sd.c         | 79 +++++++++++++++++++++++++++++++++------
 2 files changed, 68 insertions(+), 19 deletions(-)

-- 
2.39.5

[PATCH 1/2] scsi: sd: fix write_same(16/10) to enable sector size > PAGE_SIZE

[sw.prabhu6]

From: Swarna Prabhu <sw.prabhu6@gmail.com>

The WRITE SAME(16) and WRITE SAME(10) scsi commands uses
a page from a dedicated mempool('sd_page_pool') for its
payload. This pool was initialized to allocate single
pages, which was sufficient as long as the device sector
size did not exceed the PAGE_SIZE.

Given that block layer now supports block size upto
64K ie beyond PAGE_SIZE, initialize large page pool in
'sd_probe()' if a higher sector device is attached ensuring
atomicity. Adapt 'sd_set_special_bvec()' to use large page
pool when a higher sector size device is attached.

With the above fix, enable sector sizes > PAGE_SIZE in
scsi sd driver.

Cc: stable@vger.kernel.org
Signed-off-by: Swarna Prabhu <s.prabhu@samsung.com>
Co-developed-by: Pankaj Raghav <p.raghav@samsung.com>
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
---
 drivers/scsi/sd.c | 79 ++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 67 insertions(+), 12 deletions(-)

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index f50b92e63201..0e0c5dd1c668 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -112,8 +112,11 @@ static void sd_shutdown(struct device *);
 static void scsi_disk_release(struct device *cdev);
 
 static DEFINE_IDA(sd_index_ida);
+static DEFINE_MUTEX(sd_mutex_lock);
 
 static mempool_t *sd_page_pool;
+static mempool_t *sd_large_page_pool;
+static atomic_t sd_large_page_pool_users = ATOMIC_INIT(0);
 static struct lock_class_key sd_bio_compl_lkclass;
 
 static const char *sd_cache_types[] = {
@@ -922,14 +925,27 @@ static void sd_config_discard(struct scsi_disk *sdkp, struct queue_limits *lim,
 		(logical_block_size >> SECTOR_SHIFT);
 }
 
-static void *sd_set_special_bvec(struct request *rq, unsigned int data_len)
+static void *sd_set_special_bvec(struct scsi_cmnd *cmd, unsigned int data_len)
 {
 	struct page *page;
+	struct request *rq = scsi_cmd_to_rq(cmd);
+	struct scsi_device *sdp = cmd->device;
+	unsigned sector_size = sdp->sector_size;
+	unsigned int nr_pages = DIV_ROUND_UP(sector_size, PAGE_SIZE);
+	int n = 0;
 
-	page = mempool_alloc(sd_page_pool, GFP_ATOMIC);
+	if (sector_size > PAGE_SIZE)
+		page = mempool_alloc(sd_large_page_pool, GFP_ATOMIC);
+	else
+		page = mempool_alloc(sd_page_pool, GFP_ATOMIC);
 	if (!page)
 		return NULL;
-	clear_highpage(page);
+
+	do {
+		clear_highpage(page + n);
+		n++;
+	} while (n < nr_pages);
+
 	bvec_set_page(&rq->special_vec, page, data_len, 0);
 	rq->rq_flags |= RQF_SPECIAL_PAYLOAD;
 	return bvec_virt(&rq->special_vec);
@@ -945,7 +961,7 @@ static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd)
 	unsigned int data_len = 24;
 	char *buf;
 
-	buf = sd_set_special_bvec(rq, data_len);
+	buf = sd_set_special_bvec(cmd, data_len);
 	if (!buf)
 		return BLK_STS_RESOURCE;
 
@@ -1034,7 +1050,7 @@ static blk_status_t sd_setup_write_same16_cmnd(struct scsi_cmnd *cmd,
 	u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
 	u32 data_len = sdp->sector_size;
 
-	if (!sd_set_special_bvec(rq, data_len))
+	if (!sd_set_special_bvec(cmd, data_len))
 		return BLK_STS_RESOURCE;
 
 	cmd->cmd_len = 16;
@@ -1061,7 +1077,7 @@ static blk_status_t sd_setup_write_same10_cmnd(struct scsi_cmnd *cmd,
 	u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
 	u32 data_len = sdp->sector_size;
 
-	if (!sd_set_special_bvec(rq, data_len))
+	if (!sd_set_special_bvec(cmd, data_len))
 		return BLK_STS_RESOURCE;
 
 	cmd->cmd_len = 10;
@@ -1507,9 +1523,15 @@ static blk_status_t sd_init_command(struct scsi_cmnd *cmd)
 static void sd_uninit_command(struct scsi_cmnd *SCpnt)
 {
 	struct request *rq = scsi_cmd_to_rq(SCpnt);
+	struct scsi_device *sdp = SCpnt->device;
+	unsigned sector_size = sdp->sector_size;
 
-	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
-		mempool_free(rq->special_vec.bv_page, sd_page_pool);
+	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD) {
+		if (sector_size > PAGE_SIZE)
+			mempool_free(rq->special_vec.bv_page, sd_large_page_pool);
+		else
+			mempool_free(rq->special_vec.bv_page, sd_page_pool);
+	}
 }
 
 static bool sd_need_revalidate(struct gendisk *disk, struct scsi_disk *sdkp)
@@ -2920,10 +2942,7 @@ sd_read_capacity(struct scsi_disk *sdkp, struct queue_limits *lim,
 			  "assuming 512.\n");
 	}
 
-	if (sector_size != 512 &&
-	    sector_size != 1024 &&
-	    sector_size != 2048 &&
-	    sector_size != 4096) {
+	if (blk_validate_block_size(sector_size)) {
 		sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
 			  sector_size);
 		/*
@@ -4044,6 +4063,21 @@ static int sd_probe(struct device *dev)
 	sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
 
 	sd_revalidate_disk(gd);
+	if (sdp->sector_size > PAGE_SIZE) {
+		mutex_lock(&sd_mutex_lock);
+		if (!sd_large_page_pool) {
+			sd_large_page_pool = mempool_create_page_pool(
+					SD_MEMPOOL_SIZE, get_order(BLK_MAX_BLOCK_SIZE));
+			if (!sd_large_page_pool) {
+				printk(KERN_ERR "sd: can't create large page mempool\n");
+				error = -ENOMEM;
+				mutex_unlock(&sd_mutex_lock);
+				goto out_free_index;
+			}
+		}
+		atomic_inc(&sd_large_page_pool_users);
+		mutex_unlock(&sd_mutex_lock);
+	}
 
 	if (sdp->removable) {
 		gd->flags |= GENHD_FL_REMOVABLE;
@@ -4061,6 +4095,14 @@ static int sd_probe(struct device *dev)
 	if (error) {
 		device_unregister(&sdkp->disk_dev);
 		put_disk(gd);
+		if (sdp->sector_size > PAGE_SIZE) {
+			mutex_lock(&sd_mutex_lock);
+			if (atomic_dec_and_test(&sd_large_page_pool_users)) {
+				mempool_destroy(sd_large_page_pool);
+				sd_large_page_pool = NULL;
+			}
+			mutex_unlock(&sd_mutex_lock);
+		}
 		goto out;
 	}
 
@@ -4101,6 +4143,7 @@ static int sd_probe(struct device *dev)
 static int sd_remove(struct device *dev)
 {
 	struct scsi_disk *sdkp = dev_get_drvdata(dev);
+	struct scsi_device *sdp = sdkp->device;
 
 	scsi_autopm_get_device(sdkp->device);
 
@@ -4110,6 +4153,16 @@ static int sd_remove(struct device *dev)
 		sd_shutdown(dev);
 
 	put_disk(sdkp->disk);
+
+	if (sdp->sector_size > PAGE_SIZE) {
+		mutex_lock(&sd_mutex_lock);
+		if (atomic_dec_and_test(&sd_large_page_pool_users)) {
+			mempool_destroy(sd_large_page_pool);
+			sd_large_page_pool = NULL;
+		}
+		mutex_unlock(&sd_mutex_lock);
+	}
+
 	return 0;
 }
 
@@ -4446,6 +4499,8 @@ static void __exit exit_sd(void)
 
 	scsi_unregister_driver(&sd_template.gendrv);
 	mempool_destroy(sd_page_pool);
+	if (sd_large_page_pool)
+		mempool_destroy(sd_large_page_pool);
 
 	class_unregister(&sd_disk_class);
 
-- 
2.39.5

[PATCH 2/2] scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

[sw.prabhu6]

From: Swarna Prabhu <s.prabhu@samsung.com>

Now that block layer can support block size > PAGE_SIZE
and the issue with WRITE_SAME(16) and WRITE_SAME(10) are
fixed for sector sizes > PAGE_SIZE, enable sdebug_sector_size
> PAGE_SIZE in scsi_debug.

Signed-off-by: Swarna Prabhu <s.prabhu@samsung.com>
---
 drivers/scsi/scsi_debug.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index c5085e6d2e75..91f42b7e68aa 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -8508,13 +8508,7 @@ static int __init scsi_debug_init(void)
 	} else if (sdebug_ndelay > 0)
 		sdebug_jdelay = JDELAY_OVERRIDDEN;
 
-	switch (sdebug_sector_size) {
-	case  512:
-	case 1024:
-	case 2048:
-	case 4096:
-		break;
-	default:
+	if (blk_validate_block_size(sdebug_sector_size)) {
 		pr_err("invalid sector_size %d\n", sdebug_sector_size);
 		return -EINVAL;
 	}
-- 
2.39.5

Re: [PATCH 1/2] scsi: sd: fix write_same(16/10) to enable sector size > PAGE_SIZE

[Damien Le Moal]

On 2/11/26 10:50, sw.prabhu6@gmail.com wrote:
> From: Swarna Prabhu <sw.prabhu6@gmail.com>
> 
> The WRITE SAME(16) and WRITE SAME(10) scsi commands uses
> a page from a dedicated mempool('sd_page_pool') for its
> payload. This pool was initialized to allocate single
> pages, which was sufficient as long as the device sector
> size did not exceed the PAGE_SIZE.
> 
> Given that block layer now supports block size upto
> 64K ie beyond PAGE_SIZE, initialize large page pool in
> 'sd_probe()' if a higher sector device is attached ensuring
> atomicity. Adapt 'sd_set_special_bvec()' to use large page
> pool when a higher sector size device is attached.
> 
> With the above fix, enable sector sizes > PAGE_SIZE in
> scsi sd driver.

This is not a fix (as in a bug fix) but rather a new feature.

> Cc: stable@vger.kernel.org

Why ? Before this patch, scsi allows only up to 4K sector size, which is not >
PAGE_SIZE.

> Signed-off-by: Swarna Prabhu <s.prabhu@samsung.com>
> Co-developed-by: Pankaj Raghav <p.raghav@samsung.com>
> Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
> ---
>  drivers/scsi/sd.c | 79 ++++++++++++++++++++++++++++++++++++++++-------
>  1 file changed, 67 insertions(+), 12 deletions(-)
> 
> diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
> index f50b92e63201..0e0c5dd1c668 100644
> --- a/drivers/scsi/sd.c
> +++ b/drivers/scsi/sd.c
> @@ -112,8 +112,11 @@ static void sd_shutdown(struct device *);
>  static void scsi_disk_release(struct device *cdev);
>  
>  static DEFINE_IDA(sd_index_ida);
> +static DEFINE_MUTEX(sd_mutex_lock);
>  
>  static mempool_t *sd_page_pool;
> +static mempool_t *sd_large_page_pool;
> +static atomic_t sd_large_page_pool_users = ATOMIC_INIT(0);
>  static struct lock_class_key sd_bio_compl_lkclass;
>  
>  static const char *sd_cache_types[] = {
> @@ -922,14 +925,27 @@ static void sd_config_discard(struct scsi_disk *sdkp, struct queue_limits *lim,
>  		(logical_block_size >> SECTOR_SHIFT);
>  }
>  
> -static void *sd_set_special_bvec(struct request *rq, unsigned int data_len)
> +static void *sd_set_special_bvec(struct scsi_cmnd *cmd, unsigned int data_len)
>  {
>  	struct page *page;
> +	struct request *rq = scsi_cmd_to_rq(cmd);
> +	struct scsi_device *sdp = cmd->device;
> +	unsigned sector_size = sdp->sector_size;
> +	unsigned int nr_pages = DIV_ROUND_UP(sector_size, PAGE_SIZE);
> +	int n = 0;
>  
> -	page = mempool_alloc(sd_page_pool, GFP_ATOMIC);
> +	if (sector_size > PAGE_SIZE)
> +		page = mempool_alloc(sd_large_page_pool, GFP_ATOMIC);
> +	else
> +		page = mempool_alloc(sd_page_pool, GFP_ATOMIC);
>  	if (!page)
>  		return NULL;
> -	clear_highpage(page);
> +
> +	do {
> +		clear_highpage(page + n);
> +		n++;
> +	} while (n < nr_pages);

A for loop would be a lot cleaner and simpler.

> +
>  	bvec_set_page(&rq->special_vec, page, data_len, 0);
>  	rq->rq_flags |= RQF_SPECIAL_PAYLOAD;
>  	return bvec_virt(&rq->special_vec);
> @@ -945,7 +961,7 @@ static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd)
>  	unsigned int data_len = 24;
>  	char *buf;
>  
> -	buf = sd_set_special_bvec(rq, data_len);
> +	buf = sd_set_special_bvec(cmd, data_len);
>  	if (!buf)
>  		return BLK_STS_RESOURCE;
>  
> @@ -1034,7 +1050,7 @@ static blk_status_t sd_setup_write_same16_cmnd(struct scsi_cmnd *cmd,
>  	u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
>  	u32 data_len = sdp->sector_size;
>  
> -	if (!sd_set_special_bvec(rq, data_len))
> +	if (!sd_set_special_bvec(cmd, data_len))
>  		return BLK_STS_RESOURCE;
>  
>  	cmd->cmd_len = 16;
> @@ -1061,7 +1077,7 @@ static blk_status_t sd_setup_write_same10_cmnd(struct scsi_cmnd *cmd,
>  	u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
>  	u32 data_len = sdp->sector_size;
>  
> -	if (!sd_set_special_bvec(rq, data_len))
> +	if (!sd_set_special_bvec(cmd, data_len))
>  		return BLK_STS_RESOURCE;
>  
>  	cmd->cmd_len = 10;
> @@ -1507,9 +1523,15 @@ static blk_status_t sd_init_command(struct scsi_cmnd *cmd)
>  static void sd_uninit_command(struct scsi_cmnd *SCpnt)
>  {
>  	struct request *rq = scsi_cmd_to_rq(SCpnt);
> +	struct scsi_device *sdp = SCpnt->device;
> +	unsigned sector_size = sdp->sector_size;
>  
> -	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
> -		mempool_free(rq->special_vec.bv_page, sd_page_pool);
> +	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD) {
> +		if (sector_size > PAGE_SIZE)
> +			mempool_free(rq->special_vec.bv_page, sd_large_page_pool);
> +		else
> +			mempool_free(rq->special_vec.bv_page, sd_page_pool);
> +	}
>  }
>  
>  static bool sd_need_revalidate(struct gendisk *disk, struct scsi_disk *sdkp)
> @@ -2920,10 +2942,7 @@ sd_read_capacity(struct scsi_disk *sdkp, struct queue_limits *lim,
>  			  "assuming 512.\n");
>  	}
>  
> -	if (sector_size != 512 &&
> -	    sector_size != 1024 &&
> -	    sector_size != 2048 &&
> -	    sector_size != 4096) {
> +	if (blk_validate_block_size(sector_size)) {
>  		sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
>  			  sector_size);
>  		/*
> @@ -4044,6 +4063,21 @@ static int sd_probe(struct device *dev)
>  	sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
>  
>  	sd_revalidate_disk(gd);
> +	if (sdp->sector_size > PAGE_SIZE) {
> +		mutex_lock(&sd_mutex_lock);
> +		if (!sd_large_page_pool) {
> +			sd_large_page_pool = mempool_create_page_pool(
> +					SD_MEMPOOL_SIZE, get_order(BLK_MAX_BLOCK_SIZE));
> +			if (!sd_large_page_pool) {
> +				printk(KERN_ERR "sd: can't create large page mempool\n");
> +				error = -ENOMEM;
> +				mutex_unlock(&sd_mutex_lock);
> +				goto out_free_index;
> +			}
> +		}
> +		atomic_inc(&sd_large_page_pool_users);
> +		mutex_unlock(&sd_mutex_lock);
> +	}

It would be a lot nicer to have this defined as a helper function that goes
together with a pool destroy function (see below).

>  
>  	if (sdp->removable) {
>  		gd->flags |= GENHD_FL_REMOVABLE;
> @@ -4061,6 +4095,14 @@ static int sd_probe(struct device *dev)
>  	if (error) {
>  		device_unregister(&sdkp->disk_dev);
>  		put_disk(gd);
> +		if (sdp->sector_size > PAGE_SIZE) {
> +			mutex_lock(&sd_mutex_lock);
> +			if (atomic_dec_and_test(&sd_large_page_pool_users)) {
> +				mempool_destroy(sd_large_page_pool);
> +				sd_large_page_pool = NULL;
> +			}
> +			mutex_unlock(&sd_mutex_lock);
> +		}

This hunk is repeated twice. Make this a helper please.

>  		goto out;
>  	}
>  
> @@ -4101,6 +4143,7 @@ static int sd_probe(struct device *dev)
>  static int sd_remove(struct device *dev)
>  {
>  	struct scsi_disk *sdkp = dev_get_drvdata(dev);
> +	struct scsi_device *sdp = sdkp->device;
>  
>  	scsi_autopm_get_device(sdkp->device);
>  
> @@ -4110,6 +4153,16 @@ static int sd_remove(struct device *dev)
>  		sd_shutdown(dev);
>  
>  	put_disk(sdkp->disk);
> +
> +	if (sdp->sector_size > PAGE_SIZE) {
> +		mutex_lock(&sd_mutex_lock);
> +		if (atomic_dec_and_test(&sd_large_page_pool_users)) {
> +			mempool_destroy(sd_large_page_pool);
> +			sd_large_page_pool = NULL;
> +		}
> +		mutex_unlock(&sd_mutex_lock);
> +	}
> +
>  	return 0;
>  }
>  
> @@ -4446,6 +4499,8 @@ static void __exit exit_sd(void)
>  
>  	scsi_unregister_driver(&sd_template.gendrv);
>  	mempool_destroy(sd_page_pool);
> +	if (sd_large_page_pool)
> +		mempool_destroy(sd_large_page_pool);
>  
>  	class_unregister(&sd_disk_class);
>  


-- 
Damien Le Moal
Western Digital Research

Re: [PATCH 2/2] scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

[John Garry]

On 02/03/2026 12:27, Swarna Prabhu wrote:
>>>> PAGE_SIZE in scsi_debug.
>> Surely the sd driver or block layer should be catching non-compliant HW,
>> right?
> Yes, the sd driver and block layer will catch any non compliant HW.
>> The scsi_debug driver should minic HW, and there is nothing in any SCSI
>> specs which mentions that the sector size needs to be limited to 64KB or the
>> like - am I correct? The useful thing about scsi_debug is that we can
>> pretend to be broken* HW and see if the upper layers catch it.
>>
>> *broken for Linux or non-compliant wrt spec
>>
> As you pointed, the SCSI spec doesn't restrict the sector size to be
> limited to 64 KiB. Earlier block layer had limitations on block size
> upto PAGE_SIZE. With that limitation being addressed and sd driver
> change, sd driver and block layer can handle large block sizes
> correctly. By allowing large sector size on scsi debug we allow
> emulation of spec compliant HW.

Sure, so is there any reason to have those checks in scsi_debug at all? 
Would removing them break that driver and be unsafe?

Thanks,
John

> 
>>> Reviewed-by: Damien Le Moal<dlemoal@kernel.org>
>>> Signed-off-by: Swarna Prabhu<s.prabhu@samsung.com>
>>> ---
>>>    drivers/scsi/scsi_debug.c | 8 +-------
>>>    1 file changed, 1 insertion(+), 7 deletions(-)
>>>
>>> diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
>>> index c947655db518..4c6feee87f05 100644
>>> --- a/drivers/scsi/scsi_debug.c
>>> +++ b/drivers/scsi/scsi_debug.c
>>> @@ -8495,13 +8495,7 @@ static int __init scsi_debug_init(void)
>>>    	} else if (sdebug_ndelay > 0)
>>>    		sdebug_jdelay = JDELAY_OVERRIDDEN;
>>> -	switch (sdebug_sector_size) {
>>> -	case  512:
>>> -	case 1024:
>>> -	case 2048:
>>> -	case 4096:
>>> -		break;
>>> -	default:
>>> +	if (blk_validate_block_size(sdebug_sector_size)) {
>>>    		pr_err("invalid sector_size %d\n", sdebug_sector_size);
>>>    		return -EINVAL;

Re: [PATCH 2/2] scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

[Swarna Prabhu]

On Fri, Feb 27, 2026 at 08:35:32AM +0000, John Garry wrote:
> On 19/02/2026 04:37, sw.prabhu6@gmail.com wrote:
> > From: Swarna Prabhu <s.prabhu@samsung.com>
> > 
> > Now that block layer can support block size > PAGE_SIZE
> > and the issue with WRITE_SAME(16) and WRITE_SAME(10) are
> > fixed for sector sizes > PAGE_SIZE, enable sdebug_sector_size
> > > PAGE_SIZE in scsi_debug.
> > 
> 
> Surely the sd driver or block layer should be catching non-compliant HW,
> right?

Yes, the sd driver and block layer will catch any non compliant HW.
> 
> The scsi_debug driver should minic HW, and there is nothing in any SCSI
> specs which mentions that the sector size needs to be limited to 64KB or the
> like - am I correct? The useful thing about scsi_debug is that we can
> pretend to be broken* HW and see if the upper layers catch it.
> 
> *broken for Linux or non-compliant wrt spec
>

As you pointed, the SCSI spec doesn't restrict the sector size to be
limited to 64 KiB. Earlier block layer had limitations on block size
upto PAGE_SIZE. With that limitation being addressed and sd driver
change, sd driver and block layer can handle large block sizes
correctly. By allowing large sector size on scsi debug we allow 
emulation of spec compliant HW. 

Thanks
Swarna

> > Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
> > Signed-off-by: Swarna Prabhu <s.prabhu@samsung.com>
> > ---
> >   drivers/scsi/scsi_debug.c | 8 +-------
> >   1 file changed, 1 insertion(+), 7 deletions(-)
> > 
> > diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
> > index c947655db518..4c6feee87f05 100644
> > --- a/drivers/scsi/scsi_debug.c
> > +++ b/drivers/scsi/scsi_debug.c
> > @@ -8495,13 +8495,7 @@ static int __init scsi_debug_init(void)
> >   	} else if (sdebug_ndelay > 0)
> >   		sdebug_jdelay = JDELAY_OVERRIDDEN;
> > -	switch (sdebug_sector_size) {
> > -	case  512:
> > -	case 1024:
> > -	case 2048:
> > -	case 4096:
> > -		break;
> > -	default:
> > +	if (blk_validate_block_size(sdebug_sector_size)) {
> >   		pr_err("invalid sector_size %d\n", sdebug_sector_size);
> >   		return -EINVAL;
> >   	}
> 

Re: [PATCH 2/2] scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

[John Garry]

On 19/02/2026 04:37, sw.prabhu6@gmail.com wrote:
> From: Swarna Prabhu <s.prabhu@samsung.com>
> 
> Now that block layer can support block size > PAGE_SIZE
> and the issue with WRITE_SAME(16) and WRITE_SAME(10) are
> fixed for sector sizes > PAGE_SIZE, enable sdebug_sector_size
>> PAGE_SIZE in scsi_debug.
> 

Surely the sd driver or block layer should be catching non-compliant HW, 
right?

The scsi_debug driver should minic HW, and there is nothing in any SCSI 
specs which mentions that the sector size needs to be limited to 64KB or 
the like - am I correct? The useful thing about scsi_debug is that we 
can pretend to be broken* HW and see if the upper layers catch it.

*broken for Linux or non-compliant wrt spec

> Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
> Signed-off-by: Swarna Prabhu <s.prabhu@samsung.com>
> ---
>   drivers/scsi/scsi_debug.c | 8 +-------
>   1 file changed, 1 insertion(+), 7 deletions(-)
> 
> diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
> index c947655db518..4c6feee87f05 100644
> --- a/drivers/scsi/scsi_debug.c
> +++ b/drivers/scsi/scsi_debug.c
> @@ -8495,13 +8495,7 @@ static int __init scsi_debug_init(void)
>   	} else if (sdebug_ndelay > 0)
>   		sdebug_jdelay = JDELAY_OVERRIDDEN;
>   
> -	switch (sdebug_sector_size) {
> -	case  512:
> -	case 1024:
> -	case 2048:
> -	case 4096:
> -		break;
> -	default:
> +	if (blk_validate_block_size(sdebug_sector_size)) {
>   		pr_err("invalid sector_size %d\n", sdebug_sector_size);
>   		return -EINVAL;
>   	}

[PATCH 2/2] scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

[sw.prabhu6]

From: Swarna Prabhu <s.prabhu@samsung.com>

Now that block layer can support block size > PAGE_SIZE
and the issue with WRITE_SAME(16) and WRITE_SAME(10) are
fixed for sector sizes > PAGE_SIZE, enable sdebug_sector_size
> PAGE_SIZE in scsi_debug.

Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
Signed-off-by: Swarna Prabhu <s.prabhu@samsung.com>
---
 drivers/scsi/scsi_debug.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index c947655db518..4c6feee87f05 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -8495,13 +8495,7 @@ static int __init scsi_debug_init(void)
 	} else if (sdebug_ndelay > 0)
 		sdebug_jdelay = JDELAY_OVERRIDDEN;
 
-	switch (sdebug_sector_size) {
-	case  512:
-	case 1024:
-	case 2048:
-	case 4096:
-		break;
-	default:
+	if (blk_validate_block_size(sdebug_sector_size)) {
 		pr_err("invalid sector_size %d\n", sdebug_sector_size);
 		return -EINVAL;
 	}
-- 
2.39.5

[PATCH 2/2] scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

[sw.prabhu6]

From: Swarna Prabhu <sw.prabhu6@gmail.com>

Now that block layer can support block size > PAGE_SIZE
and the issue with WRITE_SAME(16) and WRITE_SAME(10) are
fixed for sector sizes > PAGE_SIZE, enable sdebug_sector_size
> PAGE_SIZE in scsi_debug.

Signed-off-by: Swarna Prabhu <s.prabhu@samsung.com>
---
 drivers/scsi/scsi_debug.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index b2ab97be5db3..2348976b3f70 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -8459,13 +8459,7 @@ static int __init scsi_debug_init(void)
 	} else if (sdebug_ndelay > 0)
 		sdebug_jdelay = JDELAY_OVERRIDDEN;
 
-	switch (sdebug_sector_size) {
-	case  512:
-	case 1024:
-	case 2048:
-	case 4096:
-		break;
-	default:
+	if (blk_validate_block_size(sdebug_sector_size)) {
 		pr_err("invalid sector_size %d\n", sdebug_sector_size);
 		return -EINVAL;
 	}
-- 
2.51.0