]> git.ipfire.org Git - thirdparty/kernel/stable.git/commitdiff
scsi: sd: Enable sector size > PAGE_SIZE in SCSI sd driver
authorSwarna Prabhu <sw.prabhu6@gmail.com>
Thu, 19 Feb 2026 04:37:42 +0000 (20:37 -0800)
committerMartin K. Petersen <martin.petersen@oracle.com>
Sun, 1 Mar 2026 01:49:00 +0000 (20:49 -0500)
The WRITE SAME(16) and WRITE SAME(10) SCSI commands use a page from a
dedicated mempool (sd_page_pool) for their 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 64KB, i.e. beyond
PAGE_SIZE, initialize a 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.

Reviewed-by: Damien Le Moal <dlemoal@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>
Link: https://patch.msgid.link/20260219043741.276729-2-sw.prabhu6@gmail.com
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
drivers/scsi/sd.c

index 628a1d0a74bac26ed47610752f9d181015195da9..205877b1f8aae5062bf2e2f1fba5f1af5313852c 100644 (file)
@@ -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 @@ got_data:
                          "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);