Skip to contentSkip to conversation

enable sector size > PAGE_SIZE for scsi

PATCH Applied [email protected] 3 participants 9 messages Feb 19 – Mar 11 SCSI

lore
Share & tools
lore
#0 lore raw

v4 cover enable sector size > PAGE_SIZE for scsi

From: Swarna Prabhu <[email protected]>

Hi All,

This is v4 series sent based on the review comments received on v3 [1]. 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 v2:
- Added reviewed by tag for scsi sd driver and scsi_debug patch.
- Modified the helper function name used for safe creation and destruction of the large page mempool.
- No functional changes.

Thanks to Damien for review.

Testing:
Testing results are same as v3 since no functional changes introduced in v4.

Link to v3: https://lore.kernel.org/all/[email protected]/ [1]

Swarna Prabhu (2):
scsi: sd: enable sector size > PAGE_SIZE in scsi sd driver
scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

 drivers/scsi/scsi_debug.c |  8 +---
 drivers/scsi/sd.c         | 80 +++++++++++++++++++++++++++++++++------
 2 files changed, 69 insertions(+), 19 deletions(-)
Signature · 1 line
2.39.5
#1 lore raw

PATCH v4 1/2 scsi: sd: enable sector size > PAGE_SIZE in scsi sd driver

From: Swarna Prabhu <[email protected]>

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. Hence enable sector sizes > PAGE_SIZE in scsi sd driver.

---
 drivers/scsi/sd.c | 80 ++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 68 insertions(+), 12 deletions(-)
drivers/scsi/sd.c +68 -12
index d76996d6cbc9..ce09239c18cb 100644
@@ -107,8 +107,11 @@ static void sd_config_write_same(struct scsi_disk *sdkp,
 static void  sd_revalidate_disk(struct gendisk *);
 
 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[] = {
@@ -116,6 +119,33 @@ static const char *sd_cache_types[] = {
 	"write back, no read (daft)"
 };
 
+static int sd_large_pool_create(void)
+{
+	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");
+			mutex_unlock(&sd_mutex_lock);
+			return -ENOMEM;
+		}
+	}
+	atomic_inc(&sd_large_page_pool_users);
+	mutex_unlock(&sd_mutex_lock);
+	return 0;
+}
+
+static void sd_large_pool_destroy(void)
+{
+	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);
+}
+
 static void sd_disable_discard(struct scsi_disk *sdkp)
 {
 	sdkp->provisioning_mode = SD_LBP_DISABLE;
@@ -928,14 +958,24 @@ static unsigned char sd_setup_protect_cmnd(struct scsi_cmnd *scmd,
 	return protect;
 }
 
-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;
 
-	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);
+
+	for (n = 0; n < nr_pages; n++)
+		clear_highpage(page + n);
 	bvec_set_page(&rq->special_vec, page, data_len, 0);
 	rq->rq_flags |= RQF_SPECIAL_PAYLOAD;
 	return bvec_virt(&rq->special_vec);
@@ -951,7 +991,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;
 
@@ -1040,7 +1080,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;
@@ -1067,7 +1107,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;
@@ -1513,9 +1553,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)
@@ -2912,10 +2958,7 @@ sd_read_capacity(struct scsi_disk *sdkp, struct queue_limits *lim,
 			  "Sector size 0 reported, 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);
 		/*
@@ -4043,6 +4086,12 @@ static int sd_probe(struct scsi_device *sdp)
 	sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
 
 	sd_revalidate_disk(gd);
+	if (sdp->sector_size > PAGE_SIZE) {
+		if (sd_large_pool_create()) {
+			error = -ENOMEM;
+			goto out_free_index;
+		}
+	}
 
 	if (sdp->removable) {
 		gd->flags |= GENHD_FL_REMOVABLE;
@@ -4060,6 +4109,8 @@ static int sd_probe(struct scsi_device *sdp)
 	if (error) {
 		device_unregister(&sdkp->disk_dev);
 		put_disk(gd);
+		if (sdp->sector_size > PAGE_SIZE)
+			sd_large_pool_destroy();
 		goto out;
 	}
 
@@ -4212,6 +4263,9 @@ static void sd_remove(struct scsi_device *sdp)
 		sd_shutdown(sdp);
 
 	put_disk(sdkp->disk);
+
+	if (sdp->sector_size > PAGE_SIZE)
+		sd_large_pool_destroy();
 }
 
 static inline bool sd_do_start_stop(struct scsi_device *sdev, bool runtime)
@@ -4435,6 +4489,8 @@ static void __exit exit_sd(void)
 
 	scsi_unregister_driver(&sd_template);
 	mempool_destroy(sd_page_pool);
+	if (sd_large_page_pool)
+		mempool_destroy(sd_large_page_pool);
 
 	class_unregister(&sd_disk_class);
 
Signature · 1 line
2.39.5
#2 lore raw

Re: [PATCH 1/2] scsi: sd: enable sector size > PAGE_SIZE in scsi sd driver

Quoted 5 lines

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.

Applied to 7.1/scsi-staging, thanks!

Signature · 1 line
Martin K. Petersen
#3 lore raw

PATCH v4 2/2 scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

In reply to [email protected]

From: Swarna Prabhu <[email protected]>

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

Quoted 1 line

PAGE_SIZE in scsi_debug.

---
 drivers/scsi/scsi_debug.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)
drivers/scsi/scsi_debug.c +1 -7
index c947655db518..4c6feee87f05 100644
@@ -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;
 	}
Signature · 1 line
2.39.5
#4 lore raw

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

Quoted 7 lines · On 19/02/2026 04:37, [email protected] wrote:

From: Swarna Prabhu <[email protected]>

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

Quoted 1 line

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

Quoted 25 lines
---
  drivers/scsi/scsi_debug.c | 8 +-------
  1 file changed, 1 insertion(+), 7 deletions(-)
drivers/scsi/scsi_debug.c +1 -7
index c947655db518..4c6feee87f05 100644
@@ -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;
  	}
#5 lore raw

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

Quoted 11 lines · John Garry
Quoted 7 lines · On 19/02/2026 04:37, [email protected] wrote:

From: Swarna Prabhu <[email protected]>

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

Quoted 1 line

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.

Quoted 8 lines

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

Quoted 25 lines
Quoted 24 lines
---
  drivers/scsi/scsi_debug.c | 8 +-------
  1 file changed, 1 insertion(+), 7 deletions(-)
drivers/scsi/scsi_debug.c +1 -7
index c947655db518..4c6feee87f05 100644
@@ -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;
  	}
#6 lore raw

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

Quoted 9 lines · Swarna Prabhu
Quoted 3 lines
Quoted 1 line
Quoted 1 line

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.

Quoted 5 lines

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.

Quoted 8 lines
Quoted 2 lines

*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

Quoted 24 lines
Quoted 24 lines
Quoted 24 lines
---
   drivers/scsi/scsi_debug.c | 8 +-------
   1 file changed, 1 insertion(+), 7 deletions(-)
drivers/scsi/scsi_debug.c +1 -7
index c947655db518..4c6feee87f05 100644
@@ -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;
#7 lore raw
In reply to [email protected]
Quoted 23 lines · On Wed, Feb 18, 2026 at 08:37:40PM -0800, [email protected] wrote:

From: Swarna Prabhu <[email protected]>

Hi All,

This is v4 series sent based on the review comments received on v3 [1]. 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 v2:
- Added reviewed by tag for scsi sd driver and scsi_debug patch.
- Modified the helper function name used for safe creation and destruction of the large page mempool.
- No functional changes.

Thanks to Damien for review.

Testing:
Testing results are same as v3 since no functional changes introduced in v4.

Link to v3: https://lore.kernel.org/all/[email protected]/ [1]

Quoted 11 lines

Swarna Prabhu (2):
scsi: sd: enable sector size > PAGE_SIZE in scsi sd driver
scsi: scsi_debug: enable sdebug_sector_size > PAGE_SIZE

 drivers/scsi/scsi_debug.c |  8 +---
 drivers/scsi/sd.c         | 80 +++++++++++++++++++++++++++++++++------
 2 files changed, 69 insertions(+), 19 deletions(-)
Signature · 1 line
2.39.5

Gentle ping.

Just wanted to make sure it didn't get lost.

Please let me know if any updates are needed.

Thank you,
Swarna Prabhu

#8 lore raw

Re: (subset) [PATCH v4 0/2] enable sector size > PAGE_SIZE for scsi

In reply to [email protected]
Quoted 6 lines · On Wed, 18 Feb 2026 20:37:40 -0800, [email protected] wrote:

This is v4 series sent based on the review comments received on v3 [1]. 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.

Quoted 7 lines

Changes since v2:
- Added reviewed by tag for scsi sd driver and scsi_debug patch.
- Modified the helper function name used for safe creation and destruction of the large page mempool.
- No functional changes.

[...]

Applied to 7.1/scsi-queue, thanks!

[1/2] scsi: sd: enable sector size > PAGE_SIZE in scsi sd driver

      https://git.kernel.org/mkp/scsi/c/7179e626b76e
Signature · 1 line
Martin K. Petersen