![Johannes Thumshirn](/assets/img/avatar_default.png)
When we loose a device for whatever reason while (re)scanning zones, we
trip over a NULL pointer in blk_revalidate_zone_cb, like in the following
log:
sd 0:0:0:0: [sda] 3418095616 4096-byte logical blocks: (14.0 TB/12.7 TiB)
sd 0:0:0:0: [sda] 52156 zones of 65536 logical blocks
sd 0:0:0:0: [sda] Write Protect is off
sd 0:0:0:0: [sda] Mode Sense: 37 00 00 08
sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
sd 0:0:0:0: [sda] REPORT ZONES start lba 1065287680 failed
sd 0:0:0:0: [sda] REPORT ZONES: Result: hostbyte=0x00 driverbyte=0x08
sd 0:0:0:0: [sda] Sense Key : 0xb [current]
sd 0:0:0:0: [sda] ASC=0x0 ASCQ=0x6
sda: failed to revalidate zones
sd 0:0:0:0: [sda] 0 4096-byte logical blocks: (0 B/0 B)
sda: detected capacity change from 14000519643136 to 0
==================================================================
BUG: KASAN: null-ptr-deref in blk_revalidate_zone_cb+0x1b7/0x550
Write of size 8 at addr 0000000000000010 by task kworker/u4:1/58
CPU: 1 PID: 58 Comm: kworker/u4:1 Not tainted 5.8.0-rc1 #692
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.13.0-0-gf21b5a4-rebuilt.opensuse.org 04/01/2014
Workqueue: events_unbound async_run_entry_fn
Call Trace:
dump_stack+0x7d/0xb0
? blk_revalidate_zone_cb+0x1b7/0x550
kasan_report.cold+0x5/0x37
? blk_revalidate_zone_cb+0x1b7/0x550
check_memory_region+0x145/0x1a0
blk_revalidate_zone_cb+0x1b7/0x550
sd_zbc_parse_report+0x1f1/0x370
? blk_req_zone_write_trylock+0x200/0x200
? sectors_to_logical+0x60/0x60
? blk_req_zone_write_trylock+0x200/0x200
? blk_req_zone_write_trylock+0x200/0x200
sd_zbc_report_zones+0x3c4/0x5e0
? sd_dif_config_host+0x500/0x500
blk_revalidate_disk_zones+0x231/0x44d
? _raw_write_lock_irqsave+0xb0/0xb0
? blk_queue_free_zone_bitmaps+0xd0/0xd0
sd_zbc_read_zones+0x8cf/0x11a0
sd_revalidate_disk+0x305c/0x64e0
? __device_add_disk+0x776/0xf20
? read_capacity_16.part.0+0x1080/0x1080
? blk_alloc_devt+0x250/0x250
? create_object.isra.0+0x595/0xa20
? kasan_unpoison_shadow+0x33/0x40
sd_probe+0x8dc/0xcd2
really_probe+0x20e/0xaf0
__driver_attach_async_helper+0x249/0x2d0
async_run_entry_fn+0xbe/0x560
process_one_work+0x764/0x1290
? _raw_read_unlock_irqrestore+0x30/0x30
worker_thread+0x598/0x12f0
? __kthread_parkme+0xc6/0x1b0
? schedule+0xed/0x2c0
? process_one_work+0x1290/0x1290
kthread+0x36b/0x440
? kthread_create_worker_on_cpu+0xa0/0xa0
ret_from_fork+0x22/0x30
==================================================================
When the device is already gone we end up with the following scenario:
The device's capacity is 0 and thus the number of zones will be 0 as well. When
allocating the bitmap for the conventional zones, we then trip over a NULL
pointer.
So if we encounter a zoned block device with a 0 capacity, don't dare to
revalidate the zones sizes.
Fixes: 6c6b354914
("block: set the zone size in blk_revalidate_disk_zones atomically")
Signed-off-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Reviewed-by: Damien Le Moal <damien.lemoal@wdc.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
538 lines
14 KiB
C
538 lines
14 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Zoned block device handling
|
|
*
|
|
* Copyright (c) 2015, Hannes Reinecke
|
|
* Copyright (c) 2015, SUSE Linux GmbH
|
|
*
|
|
* Copyright (c) 2016, Damien Le Moal
|
|
* Copyright (c) 2016, Western Digital
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/rbtree.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/blk-mq.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/sched/mm.h>
|
|
|
|
#include "blk.h"
|
|
|
|
#define ZONE_COND_NAME(name) [BLK_ZONE_COND_##name] = #name
|
|
static const char *const zone_cond_name[] = {
|
|
ZONE_COND_NAME(NOT_WP),
|
|
ZONE_COND_NAME(EMPTY),
|
|
ZONE_COND_NAME(IMP_OPEN),
|
|
ZONE_COND_NAME(EXP_OPEN),
|
|
ZONE_COND_NAME(CLOSED),
|
|
ZONE_COND_NAME(READONLY),
|
|
ZONE_COND_NAME(FULL),
|
|
ZONE_COND_NAME(OFFLINE),
|
|
};
|
|
#undef ZONE_COND_NAME
|
|
|
|
/**
|
|
* blk_zone_cond_str - Return string XXX in BLK_ZONE_COND_XXX.
|
|
* @zone_cond: BLK_ZONE_COND_XXX.
|
|
*
|
|
* Description: Centralize block layer function to convert BLK_ZONE_COND_XXX
|
|
* into string format. Useful in the debugging and tracing zone conditions. For
|
|
* invalid BLK_ZONE_COND_XXX it returns string "UNKNOWN".
|
|
*/
|
|
const char *blk_zone_cond_str(enum blk_zone_cond zone_cond)
|
|
{
|
|
static const char *zone_cond_str = "UNKNOWN";
|
|
|
|
if (zone_cond < ARRAY_SIZE(zone_cond_name) && zone_cond_name[zone_cond])
|
|
zone_cond_str = zone_cond_name[zone_cond];
|
|
|
|
return zone_cond_str;
|
|
}
|
|
EXPORT_SYMBOL_GPL(blk_zone_cond_str);
|
|
|
|
static inline sector_t blk_zone_start(struct request_queue *q,
|
|
sector_t sector)
|
|
{
|
|
sector_t zone_mask = blk_queue_zone_sectors(q) - 1;
|
|
|
|
return sector & ~zone_mask;
|
|
}
|
|
|
|
/*
|
|
* Return true if a request is a write requests that needs zone write locking.
|
|
*/
|
|
bool blk_req_needs_zone_write_lock(struct request *rq)
|
|
{
|
|
if (!rq->q->seq_zones_wlock)
|
|
return false;
|
|
|
|
if (blk_rq_is_passthrough(rq))
|
|
return false;
|
|
|
|
switch (req_op(rq)) {
|
|
case REQ_OP_WRITE_ZEROES:
|
|
case REQ_OP_WRITE_SAME:
|
|
case REQ_OP_WRITE:
|
|
return blk_rq_zone_is_seq(rq);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(blk_req_needs_zone_write_lock);
|
|
|
|
bool blk_req_zone_write_trylock(struct request *rq)
|
|
{
|
|
unsigned int zno = blk_rq_zone_no(rq);
|
|
|
|
if (test_and_set_bit(zno, rq->q->seq_zones_wlock))
|
|
return false;
|
|
|
|
WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
|
|
rq->rq_flags |= RQF_ZONE_WRITE_LOCKED;
|
|
|
|
return true;
|
|
}
|
|
EXPORT_SYMBOL_GPL(blk_req_zone_write_trylock);
|
|
|
|
void __blk_req_zone_write_lock(struct request *rq)
|
|
{
|
|
if (WARN_ON_ONCE(test_and_set_bit(blk_rq_zone_no(rq),
|
|
rq->q->seq_zones_wlock)))
|
|
return;
|
|
|
|
WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
|
|
rq->rq_flags |= RQF_ZONE_WRITE_LOCKED;
|
|
}
|
|
EXPORT_SYMBOL_GPL(__blk_req_zone_write_lock);
|
|
|
|
void __blk_req_zone_write_unlock(struct request *rq)
|
|
{
|
|
rq->rq_flags &= ~RQF_ZONE_WRITE_LOCKED;
|
|
if (rq->q->seq_zones_wlock)
|
|
WARN_ON_ONCE(!test_and_clear_bit(blk_rq_zone_no(rq),
|
|
rq->q->seq_zones_wlock));
|
|
}
|
|
EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock);
|
|
|
|
/**
|
|
* blkdev_nr_zones - Get number of zones
|
|
* @disk: Target gendisk
|
|
*
|
|
* Return the total number of zones of a zoned block device. For a block
|
|
* device without zone capabilities, the number of zones is always 0.
|
|
*/
|
|
unsigned int blkdev_nr_zones(struct gendisk *disk)
|
|
{
|
|
sector_t zone_sectors = blk_queue_zone_sectors(disk->queue);
|
|
|
|
if (!blk_queue_is_zoned(disk->queue))
|
|
return 0;
|
|
return (get_capacity(disk) + zone_sectors - 1) >> ilog2(zone_sectors);
|
|
}
|
|
EXPORT_SYMBOL_GPL(blkdev_nr_zones);
|
|
|
|
/**
|
|
* blkdev_report_zones - Get zones information
|
|
* @bdev: Target block device
|
|
* @sector: Sector from which to report zones
|
|
* @nr_zones: Maximum number of zones to report
|
|
* @cb: Callback function called for each reported zone
|
|
* @data: Private data for the callback
|
|
*
|
|
* Description:
|
|
* Get zone information starting from the zone containing @sector for at most
|
|
* @nr_zones, and call @cb for each zone reported by the device.
|
|
* To report all zones in a device starting from @sector, the BLK_ALL_ZONES
|
|
* constant can be passed to @nr_zones.
|
|
* Returns the number of zones reported by the device, or a negative errno
|
|
* value in case of failure.
|
|
*
|
|
* Note: The caller must use memalloc_noXX_save/restore() calls to control
|
|
* memory allocations done within this function.
|
|
*/
|
|
int blkdev_report_zones(struct block_device *bdev, sector_t sector,
|
|
unsigned int nr_zones, report_zones_cb cb, void *data)
|
|
{
|
|
struct gendisk *disk = bdev->bd_disk;
|
|
sector_t capacity = get_capacity(disk);
|
|
|
|
if (!blk_queue_is_zoned(bdev_get_queue(bdev)) ||
|
|
WARN_ON_ONCE(!disk->fops->report_zones))
|
|
return -EOPNOTSUPP;
|
|
|
|
if (!nr_zones || sector >= capacity)
|
|
return 0;
|
|
|
|
return disk->fops->report_zones(disk, sector, nr_zones, cb, data);
|
|
}
|
|
EXPORT_SYMBOL_GPL(blkdev_report_zones);
|
|
|
|
static inline bool blkdev_allow_reset_all_zones(struct block_device *bdev,
|
|
sector_t sector,
|
|
sector_t nr_sectors)
|
|
{
|
|
if (!blk_queue_zone_resetall(bdev_get_queue(bdev)))
|
|
return false;
|
|
|
|
/*
|
|
* REQ_OP_ZONE_RESET_ALL can be executed only if the number of sectors
|
|
* of the applicable zone range is the entire disk.
|
|
*/
|
|
return !sector && nr_sectors == get_capacity(bdev->bd_disk);
|
|
}
|
|
|
|
/**
|
|
* blkdev_zone_mgmt - Execute a zone management operation on a range of zones
|
|
* @bdev: Target block device
|
|
* @op: Operation to be performed on the zones
|
|
* @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
|
|
* @sector..@sector+@nr_sectors. Specifying the entire disk sector range
|
|
* is valid, but the specified range should not contain conventional zones.
|
|
* The operation to execute on each zone can be a zone reset, open, close
|
|
* or finish request.
|
|
*/
|
|
int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
|
|
sector_t sector, sector_t nr_sectors,
|
|
gfp_t gfp_mask)
|
|
{
|
|
struct request_queue *q = bdev_get_queue(bdev);
|
|
sector_t zone_sectors = blk_queue_zone_sectors(q);
|
|
sector_t capacity = get_capacity(bdev->bd_disk);
|
|
sector_t end_sector = sector + nr_sectors;
|
|
struct bio *bio = NULL;
|
|
int ret;
|
|
|
|
if (!blk_queue_is_zoned(q))
|
|
return -EOPNOTSUPP;
|
|
|
|
if (bdev_read_only(bdev))
|
|
return -EPERM;
|
|
|
|
if (!op_is_zone_mgmt(op))
|
|
return -EOPNOTSUPP;
|
|
|
|
if (end_sector <= sector || end_sector > capacity)
|
|
/* Out of range */
|
|
return -EINVAL;
|
|
|
|
/* Check alignment (handle eventual smaller last zone) */
|
|
if (sector & (zone_sectors - 1))
|
|
return -EINVAL;
|
|
|
|
if ((nr_sectors & (zone_sectors - 1)) && end_sector != capacity)
|
|
return -EINVAL;
|
|
|
|
while (sector < end_sector) {
|
|
bio = blk_next_bio(bio, 0, gfp_mask);
|
|
bio_set_dev(bio, bdev);
|
|
|
|
/*
|
|
* Special case for the zone reset operation that reset all
|
|
* zones, this is useful for applications like mkfs.
|
|
*/
|
|
if (op == REQ_OP_ZONE_RESET &&
|
|
blkdev_allow_reset_all_zones(bdev, sector, nr_sectors)) {
|
|
bio->bi_opf = REQ_OP_ZONE_RESET_ALL;
|
|
break;
|
|
}
|
|
|
|
bio->bi_opf = op | REQ_SYNC;
|
|
bio->bi_iter.bi_sector = sector;
|
|
sector += zone_sectors;
|
|
|
|
/* This may take a while, so be nice to others */
|
|
cond_resched();
|
|
}
|
|
|
|
ret = submit_bio_wait(bio);
|
|
bio_put(bio);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(blkdev_zone_mgmt);
|
|
|
|
struct zone_report_args {
|
|
struct blk_zone __user *zones;
|
|
};
|
|
|
|
static int blkdev_copy_zone_to_user(struct blk_zone *zone, unsigned int idx,
|
|
void *data)
|
|
{
|
|
struct zone_report_args *args = data;
|
|
|
|
if (copy_to_user(&args->zones[idx], zone, sizeof(struct blk_zone)))
|
|
return -EFAULT;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* BLKREPORTZONE ioctl processing.
|
|
* Called from blkdev_ioctl.
|
|
*/
|
|
int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
void __user *argp = (void __user *)arg;
|
|
struct zone_report_args args;
|
|
struct request_queue *q;
|
|
struct blk_zone_report rep;
|
|
int ret;
|
|
|
|
if (!argp)
|
|
return -EINVAL;
|
|
|
|
q = bdev_get_queue(bdev);
|
|
if (!q)
|
|
return -ENXIO;
|
|
|
|
if (!blk_queue_is_zoned(q))
|
|
return -ENOTTY;
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EACCES;
|
|
|
|
if (copy_from_user(&rep, argp, sizeof(struct blk_zone_report)))
|
|
return -EFAULT;
|
|
|
|
if (!rep.nr_zones)
|
|
return -EINVAL;
|
|
|
|
args.zones = argp + sizeof(struct blk_zone_report);
|
|
ret = blkdev_report_zones(bdev, rep.sector, rep.nr_zones,
|
|
blkdev_copy_zone_to_user, &args);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
rep.nr_zones = ret;
|
|
rep.flags = BLK_ZONE_REP_CAPACITY;
|
|
if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report)))
|
|
return -EFAULT;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* BLKRESETZONE, BLKOPENZONE, BLKCLOSEZONE and BLKFINISHZONE ioctl processing.
|
|
* Called from blkdev_ioctl.
|
|
*/
|
|
int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
void __user *argp = (void __user *)arg;
|
|
struct request_queue *q;
|
|
struct blk_zone_range zrange;
|
|
enum req_opf op;
|
|
|
|
if (!argp)
|
|
return -EINVAL;
|
|
|
|
q = bdev_get_queue(bdev);
|
|
if (!q)
|
|
return -ENXIO;
|
|
|
|
if (!blk_queue_is_zoned(q))
|
|
return -ENOTTY;
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EACCES;
|
|
|
|
if (!(mode & FMODE_WRITE))
|
|
return -EBADF;
|
|
|
|
if (copy_from_user(&zrange, argp, sizeof(struct blk_zone_range)))
|
|
return -EFAULT;
|
|
|
|
switch (cmd) {
|
|
case BLKRESETZONE:
|
|
op = REQ_OP_ZONE_RESET;
|
|
break;
|
|
case BLKOPENZONE:
|
|
op = REQ_OP_ZONE_OPEN;
|
|
break;
|
|
case BLKCLOSEZONE:
|
|
op = REQ_OP_ZONE_CLOSE;
|
|
break;
|
|
case BLKFINISHZONE:
|
|
op = REQ_OP_ZONE_FINISH;
|
|
break;
|
|
default:
|
|
return -ENOTTY;
|
|
}
|
|
|
|
return blkdev_zone_mgmt(bdev, op, zrange.sector, zrange.nr_sectors,
|
|
GFP_KERNEL);
|
|
}
|
|
|
|
static inline unsigned long *blk_alloc_zone_bitmap(int node,
|
|
unsigned int nr_zones)
|
|
{
|
|
return kcalloc_node(BITS_TO_LONGS(nr_zones), sizeof(unsigned long),
|
|
GFP_NOIO, node);
|
|
}
|
|
|
|
void blk_queue_free_zone_bitmaps(struct request_queue *q)
|
|
{
|
|
kfree(q->conv_zones_bitmap);
|
|
q->conv_zones_bitmap = NULL;
|
|
kfree(q->seq_zones_wlock);
|
|
q->seq_zones_wlock = NULL;
|
|
}
|
|
|
|
struct blk_revalidate_zone_args {
|
|
struct gendisk *disk;
|
|
unsigned long *conv_zones_bitmap;
|
|
unsigned long *seq_zones_wlock;
|
|
unsigned int nr_zones;
|
|
sector_t zone_sectors;
|
|
sector_t sector;
|
|
};
|
|
|
|
/*
|
|
* Helper function to check the validity of zones of a zoned block device.
|
|
*/
|
|
static int blk_revalidate_zone_cb(struct blk_zone *zone, unsigned int idx,
|
|
void *data)
|
|
{
|
|
struct blk_revalidate_zone_args *args = data;
|
|
struct gendisk *disk = args->disk;
|
|
struct request_queue *q = disk->queue;
|
|
sector_t capacity = get_capacity(disk);
|
|
|
|
/*
|
|
* All zones must have the same size, with the exception on an eventual
|
|
* smaller last zone.
|
|
*/
|
|
if (zone->start == 0) {
|
|
if (zone->len == 0 || !is_power_of_2(zone->len)) {
|
|
pr_warn("%s: Invalid zoned device with non power of two zone size (%llu)\n",
|
|
disk->disk_name, zone->len);
|
|
return -ENODEV;
|
|
}
|
|
|
|
args->zone_sectors = zone->len;
|
|
args->nr_zones = (capacity + zone->len - 1) >> ilog2(zone->len);
|
|
} else if (zone->start + args->zone_sectors < capacity) {
|
|
if (zone->len != args->zone_sectors) {
|
|
pr_warn("%s: Invalid zoned device with non constant zone size\n",
|
|
disk->disk_name);
|
|
return -ENODEV;
|
|
}
|
|
} else {
|
|
if (zone->len > args->zone_sectors) {
|
|
pr_warn("%s: Invalid zoned device with larger last zone size\n",
|
|
disk->disk_name);
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
|
|
/* Check for holes in the zone report */
|
|
if (zone->start != args->sector) {
|
|
pr_warn("%s: Zone gap at sectors %llu..%llu\n",
|
|
disk->disk_name, args->sector, zone->start);
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* Check zone type */
|
|
switch (zone->type) {
|
|
case BLK_ZONE_TYPE_CONVENTIONAL:
|
|
if (!args->conv_zones_bitmap) {
|
|
args->conv_zones_bitmap =
|
|
blk_alloc_zone_bitmap(q->node, args->nr_zones);
|
|
if (!args->conv_zones_bitmap)
|
|
return -ENOMEM;
|
|
}
|
|
set_bit(idx, args->conv_zones_bitmap);
|
|
break;
|
|
case BLK_ZONE_TYPE_SEQWRITE_REQ:
|
|
case BLK_ZONE_TYPE_SEQWRITE_PREF:
|
|
if (!args->seq_zones_wlock) {
|
|
args->seq_zones_wlock =
|
|
blk_alloc_zone_bitmap(q->node, args->nr_zones);
|
|
if (!args->seq_zones_wlock)
|
|
return -ENOMEM;
|
|
}
|
|
break;
|
|
default:
|
|
pr_warn("%s: Invalid zone type 0x%x at sectors %llu\n",
|
|
disk->disk_name, (int)zone->type, zone->start);
|
|
return -ENODEV;
|
|
}
|
|
|
|
args->sector += zone->len;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* blk_revalidate_disk_zones - (re)allocate and initialize zone bitmaps
|
|
* @disk: Target disk
|
|
* @update_driver_data: Callback to update driver data on the frozen disk
|
|
*
|
|
* Helper function for low-level device drivers to (re) allocate and initialize
|
|
* a disk request queue zone bitmaps. This functions should normally be called
|
|
* within the disk ->revalidate method for blk-mq based drivers. For BIO based
|
|
* drivers only q->nr_zones needs to be updated so that the sysfs exposed value
|
|
* is correct.
|
|
* If the @update_driver_data callback function is not NULL, the callback is
|
|
* executed with the device request queue frozen after all zones have been
|
|
* checked.
|
|
*/
|
|
int blk_revalidate_disk_zones(struct gendisk *disk,
|
|
void (*update_driver_data)(struct gendisk *disk))
|
|
{
|
|
struct request_queue *q = disk->queue;
|
|
struct blk_revalidate_zone_args args = {
|
|
.disk = disk,
|
|
};
|
|
unsigned int noio_flag;
|
|
int ret;
|
|
|
|
if (WARN_ON_ONCE(!blk_queue_is_zoned(q)))
|
|
return -EIO;
|
|
if (WARN_ON_ONCE(!queue_is_mq(q)))
|
|
return -EIO;
|
|
|
|
if (!get_capacity(disk))
|
|
return -EIO;
|
|
|
|
/*
|
|
* Ensure that all memory allocations in this context are done as if
|
|
* GFP_NOIO was specified.
|
|
*/
|
|
noio_flag = memalloc_noio_save();
|
|
ret = disk->fops->report_zones(disk, 0, UINT_MAX,
|
|
blk_revalidate_zone_cb, &args);
|
|
memalloc_noio_restore(noio_flag);
|
|
|
|
/*
|
|
* Install the new bitmaps and update nr_zones only once the queue is
|
|
* stopped and all I/Os are completed (i.e. a scheduler is not
|
|
* referencing the bitmaps).
|
|
*/
|
|
blk_mq_freeze_queue(q);
|
|
if (ret >= 0) {
|
|
blk_queue_chunk_sectors(q, args.zone_sectors);
|
|
q->nr_zones = args.nr_zones;
|
|
swap(q->seq_zones_wlock, args.seq_zones_wlock);
|
|
swap(q->conv_zones_bitmap, args.conv_zones_bitmap);
|
|
if (update_driver_data)
|
|
update_driver_data(disk);
|
|
ret = 0;
|
|
} else {
|
|
pr_warn("%s: failed to revalidate zones\n", disk->disk_name);
|
|
blk_queue_free_zone_bitmaps(q);
|
|
}
|
|
blk_mq_unfreeze_queue(q);
|
|
|
|
kfree(args.seq_zones_wlock);
|
|
kfree(args.conv_zones_bitmap);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(blk_revalidate_disk_zones);
|