block: remove gfp_flags from blkdev_zone_mgmt

Now that all callers pass in GFP_KERNEL to blkdev_zone_mgmt() and use
memalloc_no{io,fs}_{save,restore}() to define the allocation scope, we can
drop the gfp_mask parameter from blkdev_zone_mgmt() as well as
blkdev_zone_reset_all() and blkdev_zone_reset_all_emulated().

Signed-off-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
Reviewed-by: Mike Snitzer <snitzer@kernel.org>
Link: https://lore.kernel.org/r/20240128-zonefs_nofs-v3-5-ae3b7c8def61@wdc.com
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/block/blk-zoned.c b/block/blk-zoned.c
index d343e5756a9c8048374edcce8000230eed10480b..d4f4f8325eff0a174699438d837ea4a14a8ca77b 100644 (file)
--- a/block/blk-zoned.c
+++ b/block/blk-zoned.c
@@ -177,8 +177,7 @@ static int blk_zone_need_reset_cb(struct blk_zone *zone, unsigned int idx,
        }
 }
 
-static int blkdev_zone_reset_all_emulated(struct block_device *bdev,
-                                         gfp_t gfp_mask)
+static int blkdev_zone_reset_all_emulated(struct block_device *bdev)
 {
        struct gendisk *disk = bdev->bd_disk;
        sector_t capacity = bdev_nr_sectors(bdev);
@@ -205,7 +204,7 @@ static int blkdev_zone_reset_all_emulated(struct block_device *bdev,
                }
 
                bio = blk_next_bio(bio, bdev, 0, REQ_OP_ZONE_RESET | REQ_SYNC,
-                                  gfp_mask);
+                                  GFP_KERNEL);
                bio->bi_iter.bi_sector = sector;
                sector += zone_sectors;
 
@@ -223,7 +222,7 @@ out_free_need_reset:
        return ret;
 }
 
-static int blkdev_zone_reset_all(struct block_device *bdev, gfp_t gfp_mask)
+static int blkdev_zone_reset_all(struct block_device *bdev)
 {
        struct bio bio;
 
@@ -238,7 +237,6 @@ static int blkdev_zone_reset_all(struct block_device *bdev, gfp_t gfp_mask)
  * @sector:    Start sector of the first zone to operate on
  * @nr_sectors:        Number of sectors, should be at least the length of one zone and
  *             must be zone size aligned.
- * @gfp_mask:  Memory allocation flags (for bio_alloc)
  *
  * Description:
  *    Perform the specified operation on the range of zones specified by
@@ -248,7 +246,7 @@ static int blkdev_zone_reset_all(struct block_device *bdev, gfp_t gfp_mask)
  *    or finish request.
  */
 int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
-                    sector_t sector, sector_t nr_sectors, gfp_t gfp_mask)
+                    sector_t sector, sector_t nr_sectors)
 {
        struct request_queue *q = bdev_get_queue(bdev);
        sector_t zone_sectors = bdev_zone_sectors(bdev);
@@ -285,12 +283,12 @@ int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
         */
        if (op == REQ_OP_ZONE_RESET && sector == 0 && nr_sectors == capacity) {
                if (!blk_queue_zone_resetall(q))
-                       return blkdev_zone_reset_all_emulated(bdev, gfp_mask);
-               return blkdev_zone_reset_all(bdev, gfp_mask);
+                       return blkdev_zone_reset_all_emulated(bdev);
+               return blkdev_zone_reset_all(bdev);
        }
 
        while (sector < end_sector) {
-               bio = blk_next_bio(bio, bdev, 0, op | REQ_SYNC, gfp_mask);
+               bio = blk_next_bio(bio, bdev, 0, op | REQ_SYNC, GFP_KERNEL);
                bio->bi_iter.bi_sector = sector;
                sector += zone_sectors;
 
@@ -419,8 +417,7 @@ int blkdev_zone_mgmt_ioctl(struct block_device *bdev, blk_mode_t mode,
                return -ENOTTY;
        }
 
-       ret = blkdev_zone_mgmt(bdev, op, zrange.sector, zrange.nr_sectors,
-                              GFP_KERNEL);
+       ret = blkdev_zone_mgmt(bdev, op, zrange.sector, zrange.nr_sectors);
 
 fail:
        if (cmd == BLKRESETZONE)

diff --git a/drivers/md/dm-zoned-metadata.c b/drivers/md/dm-zoned-metadata.c
index 165996cc966c4526a1bd8a9cac698966feef187b..8156881a31de93d4b155051e8085ceb90216aa46 100644 (file)
--- a/drivers/md/dm-zoned-metadata.c
+++ b/drivers/md/dm-zoned-metadata.c
@@ -1660,7 +1660,7 @@ static int dmz_reset_zone(struct dmz_metadata *zmd, struct dm_zone *zone)
                noio_flag = memalloc_noio_save();
                ret = blkdev_zone_mgmt(dev->bdev, REQ_OP_ZONE_RESET,
                                       dmz_start_sect(zmd, zone),
-                                      zmd->zone_nr_sectors, GFP_KERNEL);
+                                      zmd->zone_nr_sectors);
                memalloc_noio_restore(noio_flag);
                if (ret) {
                        dmz_dev_err(dev, "Reset zone %u failed %d",

diff --git a/drivers/nvme/target/zns.c b/drivers/nvme/target/zns.c
index 5b5c1e48172213df20683d8c117a9586b733bfa5..3148d9f1bde66ac44d114b71f45c98ab52a6ed24 100644 (file)
--- a/drivers/nvme/target/zns.c
+++ b/drivers/nvme/target/zns.c
@@ -456,8 +456,7 @@ static u16 nvmet_bdev_execute_zmgmt_send_all(struct nvmet_req *req)
        switch (zsa_req_op(req->cmd->zms.zsa)) {
        case REQ_OP_ZONE_RESET:
                ret = blkdev_zone_mgmt(req->ns->bdev, REQ_OP_ZONE_RESET, 0,
-                                      get_capacity(req->ns->bdev->bd_disk),
-                                      GFP_KERNEL);
+                                      get_capacity(req->ns->bdev->bd_disk));
                if (ret < 0)
                        return blkdev_zone_mgmt_errno_to_nvme_status(ret);
                break;
@@ -508,7 +507,7 @@ static void nvmet_bdev_zmgmt_send_work(struct work_struct *w)
                goto out;
        }
 
-       ret = blkdev_zone_mgmt(bdev, op, sect, zone_sectors, GFP_KERNEL);
+       ret = blkdev_zone_mgmt(bdev, op, sect, zone_sectors);
        if (ret < 0)
                status = blkdev_zone_mgmt_errno_to_nvme_status(ret);
 

diff --git a/fs/btrfs/zoned.c b/fs/btrfs/zoned.c
index 05640d61e435f504ea033ee3276aa18d907c8dbd..cf2e779d8ef4fd85508049bad32a0cc875322760 100644 (file)
--- a/fs/btrfs/zoned.c
+++ b/fs/btrfs/zoned.c
@@ -830,8 +830,7 @@ static int sb_log_location(struct block_device *bdev, struct blk_zone *zones,
 
                        nofs_flags = memalloc_nofs_save();
                        ret = blkdev_zone_mgmt(bdev, REQ_OP_ZONE_RESET,
-                                              reset->start, reset->len,
-                                              GFP_KERNEL);
+                                              reset->start, reset->len);
                        memalloc_nofs_restore(nofs_flags);
                        if (ret)
                                return ret;
@@ -984,7 +983,7 @@ int btrfs_advance_sb_log(struct btrfs_device *device, int mirror)
                                nofs_flags = memalloc_nofs_save();
                                ret = blkdev_zone_mgmt(device->bdev,
                                                REQ_OP_ZONE_FINISH, zone->start,
-                                               zone->len, GFP_KERNEL);
+                                               zone->len);
                                memalloc_nofs_restore(nofs_flags);
                                if (ret)
                                        return ret;
@@ -1023,8 +1022,7 @@ int btrfs_reset_sb_log_zones(struct block_device *bdev, int mirror)
        nofs_flags = memalloc_nofs_save();
        ret = blkdev_zone_mgmt(bdev, REQ_OP_ZONE_RESET,
                               zone_start_sector(sb_zone, bdev),
-                              zone_sectors * BTRFS_NR_SB_LOG_ZONES,
-                              GFP_KERNEL);
+                              zone_sectors * BTRFS_NR_SB_LOG_ZONES);
        memalloc_nofs_restore(nofs_flags);
        return ret;
 }
@@ -1143,8 +1141,7 @@ int btrfs_reset_device_zone(struct btrfs_device *device, u64 physical,
        *bytes = 0;
        nofs_flags = memalloc_nofs_save();
        ret = blkdev_zone_mgmt(device->bdev, REQ_OP_ZONE_RESET,
-                              physical >> SECTOR_SHIFT, length >> SECTOR_SHIFT,
-                              GFP_KERNEL);
+                              physical >> SECTOR_SHIFT, length >> SECTOR_SHIFT);
        memalloc_nofs_restore(nofs_flags);
        if (ret)
                return ret;
@@ -2258,8 +2255,7 @@ static int do_zone_finish(struct btrfs_block_group *block_group, bool fully_writ
                nofs_flags = memalloc_nofs_save();
                ret = blkdev_zone_mgmt(device->bdev, REQ_OP_ZONE_FINISH,
                                       physical >> SECTOR_SHIFT,
-                                      zinfo->zone_size >> SECTOR_SHIFT,
-                                      GFP_KERNEL);
+                                      zinfo->zone_size >> SECTOR_SHIFT);
                memalloc_nofs_restore(nofs_flags);
 
                if (ret)

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 0094fe4913645fcfee6da8062e3dd6da0dfac066..e1065ba702076131067091fe173b19edab41b5d1 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -1977,7 +1977,7 @@ static int __f2fs_issue_discard_zone(struct f2fs_sb_info *sbi,
                        trace_f2fs_issue_reset_zone(bdev, blkstart);
                        nofs_flags = memalloc_nofs_save();
                        ret = blkdev_zone_mgmt(bdev, REQ_OP_ZONE_RESET,
-                                               sector, nr_sects, GFP_KERNEL);
+                                               sector, nr_sects);
                        memalloc_nofs_restore(nofs_flags);
                        return ret;
                }
@@ -4921,7 +4921,7 @@ static int check_zone_write_pointer(struct f2fs_sb_info *sbi,
 
        nofs_flags = memalloc_nofs_save();
        ret = blkdev_zone_mgmt(fdev->bdev, REQ_OP_ZONE_FINISH,
-                               zone->start, zone->len, GFP_KERNEL);
+                               zone->start, zone->len);
        memalloc_nofs_restore(nofs_flags);
        if (ret == -EOPNOTSUPP) {
                ret = blkdev_issue_zeroout(fdev->bdev, zone->wp,

diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
index 63fbac018c04550cb5744698620b8ba613828f96..cadb1364f951ce704e89922650a820fde77b736f 100644 (file)
--- a/fs/zonefs/super.c
+++ b/fs/zonefs/super.c
@@ -113,7 +113,7 @@ static int zonefs_zone_mgmt(struct super_block *sb,
 
        trace_zonefs_zone_mgmt(sb, z, op);
        ret = blkdev_zone_mgmt(sb->s_bdev, op, z->z_sector,
-                              z->z_size >> SECTOR_SHIFT, GFP_KERNEL);
+                              z->z_size >> SECTOR_SHIFT);
        if (ret) {
                zonefs_err(sb,
                           "Zone management operation %s at %llu failed %d\n",

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index d7cac3de65b31bc0cb5a5a62c6896ce69925f5ec..fac580976e3a693d8948c64d64857dc8b7deb6db 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -325,7 +325,7 @@ void disk_set_zoned(struct gendisk *disk);
 int blkdev_report_zones(struct block_device *bdev, sector_t sector,
                unsigned int nr_zones, report_zones_cb cb, void *data);
 int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
-               sector_t sectors, sector_t nr_sectors, gfp_t gfp_mask);
+               sector_t sectors, sector_t nr_sectors);
 int blk_revalidate_disk_zones(struct gendisk *disk,
                void (*update_driver_data)(struct gendisk *disk));