Blame view
block/blk-zoned.c
14 KB
3dcf60bcb block: add SPDX t... |
1 |
// SPDX-License-Identifier: GPL-2.0 |
6a0cb1bc1 block: Implement ... |
2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
/* * 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> |
bf5054569 block: Introduce ... |
16 |
#include <linux/blk-mq.h> |
26202928f block: Limit zone... |
17 18 |
#include <linux/mm.h> #include <linux/vmalloc.h> |
bd976e527 block: Kill gfp_t... |
19 |
#include <linux/sched/mm.h> |
6a0cb1bc1 block: Implement ... |
20 |
|
a2d6b3a2d block: Improve zo... |
21 |
#include "blk.h" |
02694e863 block: add a zone... |
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
#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); |
6a0cb1bc1 block: Implement ... |
53 54 55 |
static inline sector_t blk_zone_start(struct request_queue *q, sector_t sector) { |
f99e86485 block: Rename blk... |
56 |
sector_t zone_mask = blk_queue_zone_sectors(q) - 1; |
6a0cb1bc1 block: Implement ... |
57 58 59 60 61 |
return sector & ~zone_mask; } /* |
6cc77e9cb block: introduce ... |
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
* 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); |
1392d3701 block: introduce ... |
82 83 84 85 86 87 88 89 90 91 92 93 94 |
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); |
6cc77e9cb block: introduce ... |
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
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); |
a91e13802 block: Introduce ... |
114 115 |
/** * blkdev_nr_zones - Get number of zones |
9b38bb4b1 block: simplify b... |
116 |
* @disk: Target gendisk |
a91e13802 block: Introduce ... |
117 |
* |
9b38bb4b1 block: simplify b... |
118 119 |
* 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. |
a91e13802 block: Introduce ... |
120 |
*/ |
9b38bb4b1 block: simplify b... |
121 |
unsigned int blkdev_nr_zones(struct gendisk *disk) |
a91e13802 block: Introduce ... |
122 |
{ |
9b38bb4b1 block: simplify b... |
123 |
sector_t zone_sectors = blk_queue_zone_sectors(disk->queue); |
a91e13802 block: Introduce ... |
124 |
|
9b38bb4b1 block: simplify b... |
125 |
if (!blk_queue_is_zoned(disk->queue)) |
a91e13802 block: Introduce ... |
126 |
return 0; |
9b38bb4b1 block: simplify b... |
127 |
return (get_capacity(disk) + zone_sectors - 1) >> ilog2(zone_sectors); |
a91e13802 block: Introduce ... |
128 129 |
} EXPORT_SYMBOL_GPL(blkdev_nr_zones); |
6a0cb1bc1 block: Implement ... |
130 131 132 133 |
/** * blkdev_report_zones - Get zones information * @bdev: Target block device * @sector: Sector from which to report zones |
d41003513 block: rework zon... |
134 135 136 |
* @nr_zones: Maximum number of zones to report * @cb: Callback function called for each reported zone * @data: Private data for the callback |
6a0cb1bc1 block: Implement ... |
137 138 |
* * Description: |
d41003513 block: rework zon... |
139 140 141 142 143 144 145 146 147 |
* 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. |
6a0cb1bc1 block: Implement ... |
148 |
*/ |
e76239a37 block: add a repo... |
149 |
int blkdev_report_zones(struct block_device *bdev, sector_t sector, |
d41003513 block: rework zon... |
150 |
unsigned int nr_zones, report_zones_cb cb, void *data) |
6a0cb1bc1 block: Implement ... |
151 |
{ |
ceeb373aa block: Simplify r... |
152 |
struct gendisk *disk = bdev->bd_disk; |
5eac3eb30 block: Remove par... |
153 |
sector_t capacity = get_capacity(disk); |
6a0cb1bc1 block: Implement ... |
154 |
|
d41003513 block: rework zon... |
155 156 |
if (!blk_queue_is_zoned(bdev_get_queue(bdev)) || WARN_ON_ONCE(!disk->fops->report_zones)) |
e76239a37 block: add a repo... |
157 |
return -EOPNOTSUPP; |
6a0cb1bc1 block: Implement ... |
158 |
|
d41003513 block: rework zon... |
159 |
if (!nr_zones || sector >= capacity) |
6a0cb1bc1 block: Implement ... |
160 |
return 0; |
6a0cb1bc1 block: Implement ... |
161 |
|
d41003513 block: rework zon... |
162 |
return disk->fops->report_zones(disk, sector, nr_zones, cb, data); |
6a0cb1bc1 block: Implement ... |
163 164 |
} EXPORT_SYMBOL_GPL(blkdev_report_zones); |
6e33dbf28 blk-zoned: implem... |
165 |
static inline bool blkdev_allow_reset_all_zones(struct block_device *bdev, |
c7a1d926d block: Simplify R... |
166 |
sector_t sector, |
6e33dbf28 blk-zoned: implem... |
167 168 169 170 |
sector_t nr_sectors) { if (!blk_queue_zone_resetall(bdev_get_queue(bdev))) return false; |
6e33dbf28 blk-zoned: implem... |
171 |
/* |
5eac3eb30 block: Remove par... |
172 173 |
* REQ_OP_ZONE_RESET_ALL can be executed only if the number of sectors * of the applicable zone range is the entire disk. |
6e33dbf28 blk-zoned: implem... |
174 |
*/ |
5eac3eb30 block: Remove par... |
175 |
return !sector && nr_sectors == get_capacity(bdev->bd_disk); |
6e33dbf28 blk-zoned: implem... |
176 |
} |
6a0cb1bc1 block: Implement ... |
177 |
/** |
6c1b1da58 block: add zone o... |
178 |
* blkdev_zone_mgmt - Execute a zone management operation on a range of zones |
6a0cb1bc1 block: Implement ... |
179 |
* @bdev: Target block device |
6c1b1da58 block: add zone o... |
180 181 182 183 |
* @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. |
6a0cb1bc1 block: Implement ... |
184 185 186 |
* @gfp_mask: Memory allocation flags (for bio_alloc) * * Description: |
6c1b1da58 block: add zone o... |
187 |
* Perform the specified operation on the range of zones specified by |
6a0cb1bc1 block: Implement ... |
188 189 |
* @sector..@sector+@nr_sectors. Specifying the entire disk sector range * is valid, but the specified range should not contain conventional zones. |
6c1b1da58 block: add zone o... |
190 191 |
* The operation to execute on each zone can be a zone reset, open, close * or finish request. |
6a0cb1bc1 block: Implement ... |
192 |
*/ |
6c1b1da58 block: add zone o... |
193 194 195 |
int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op, sector_t sector, sector_t nr_sectors, gfp_t gfp_mask) |
6a0cb1bc1 block: Implement ... |
196 197 |
{ struct request_queue *q = bdev_get_queue(bdev); |
6c1b1da58 block: add zone o... |
198 |
sector_t zone_sectors = blk_queue_zone_sectors(q); |
5eac3eb30 block: Remove par... |
199 |
sector_t capacity = get_capacity(bdev->bd_disk); |
6a0cb1bc1 block: Implement ... |
200 |
sector_t end_sector = sector + nr_sectors; |
a2d6b3a2d block: Improve zo... |
201 |
struct bio *bio = NULL; |
6a0cb1bc1 block: Implement ... |
202 |
int ret; |
6a0cb1bc1 block: Implement ... |
203 204 |
if (!blk_queue_is_zoned(q)) return -EOPNOTSUPP; |
a2d6b3a2d block: Improve zo... |
205 206 |
if (bdev_read_only(bdev)) return -EPERM; |
6c1b1da58 block: add zone o... |
207 208 |
if (!op_is_zone_mgmt(op)) return -EOPNOTSUPP; |
11bde9860 block, zoned: fix... |
209 |
if (end_sector <= sector || end_sector > capacity) |
6a0cb1bc1 block: Implement ... |
210 211 212 213 |
/* Out of range */ return -EINVAL; /* Check alignment (handle eventual smaller last zone) */ |
6a0cb1bc1 block: Implement ... |
214 215 |
if (sector & (zone_sectors - 1)) return -EINVAL; |
5eac3eb30 block: Remove par... |
216 |
if ((nr_sectors & (zone_sectors - 1)) && end_sector != capacity) |
6a0cb1bc1 block: Implement ... |
217 218 219 |
return -EINVAL; while (sector < end_sector) { |
a2d6b3a2d block: Improve zo... |
220 |
bio = blk_next_bio(bio, 0, gfp_mask); |
74d46992e block: replace bi... |
221 |
bio_set_dev(bio, bdev); |
6a0cb1bc1 block: Implement ... |
222 |
|
c7a1d926d block: Simplify R... |
223 224 225 226 |
/* * Special case for the zone reset operation that reset all * zones, this is useful for applications like mkfs. */ |
6c1b1da58 block: add zone o... |
227 228 |
if (op == REQ_OP_ZONE_RESET && blkdev_allow_reset_all_zones(bdev, sector, nr_sectors)) { |
c7a1d926d block: Simplify R... |
229 230 231 |
bio->bi_opf = REQ_OP_ZONE_RESET_ALL; break; } |
8e42d239c block: mark zone-... |
232 |
bio->bi_opf = op | REQ_SYNC; |
c7a1d926d block: Simplify R... |
233 |
bio->bi_iter.bi_sector = sector; |
6a0cb1bc1 block: Implement ... |
234 235 236 237 |
sector += zone_sectors; /* This may take a while, so be nice to others */ cond_resched(); |
6a0cb1bc1 block: Implement ... |
238 |
} |
a2d6b3a2d block: Improve zo... |
239 240 |
ret = submit_bio_wait(bio); bio_put(bio); |
a2d6b3a2d block: Improve zo... |
241 |
return ret; |
6a0cb1bc1 block: Implement ... |
242 |
} |
6c1b1da58 block: add zone o... |
243 |
EXPORT_SYMBOL_GPL(blkdev_zone_mgmt); |
3ed05a987 blk-zoned: implem... |
244 |
|
d41003513 block: rework zon... |
245 246 247 248 249 250 251 252 253 254 255 256 257 |
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; } |
56c4bddb9 block: Suppress k... |
258 |
/* |
3ed05a987 blk-zoned: implem... |
259 260 261 262 263 264 265 |
* 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; |
d41003513 block: rework zon... |
266 |
struct zone_report_args args; |
3ed05a987 blk-zoned: implem... |
267 268 |
struct request_queue *q; struct blk_zone_report rep; |
3ed05a987 blk-zoned: implem... |
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 |
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; |
d41003513 block: rework zon... |
289 290 291 292 293 |
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; |
3ed05a987 blk-zoned: implem... |
294 |
|
d41003513 block: rework zon... |
295 |
rep.nr_zones = ret; |
82394db73 block: add capaci... |
296 |
rep.flags = BLK_ZONE_REP_CAPACITY; |
d41003513 block: rework zon... |
297 298 299 |
if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report))) return -EFAULT; return 0; |
3ed05a987 blk-zoned: implem... |
300 |
} |
56c4bddb9 block: Suppress k... |
301 |
/* |
e876df1fe block: add zone o... |
302 |
* BLKRESETZONE, BLKOPENZONE, BLKCLOSEZONE and BLKFINISHZONE ioctl processing. |
3ed05a987 blk-zoned: implem... |
303 304 |
* Called from blkdev_ioctl. */ |
e876df1fe block: add zone o... |
305 306 |
int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg) |
3ed05a987 blk-zoned: implem... |
307 308 309 310 |
{ void __user *argp = (void __user *)arg; struct request_queue *q; struct blk_zone_range zrange; |
e876df1fe block: add zone o... |
311 |
enum req_opf op; |
3ed05a987 blk-zoned: implem... |
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 |
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; |
e876df1fe block: add zone o... |
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 |
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); |
3ed05a987 blk-zoned: implem... |
350 |
} |
bf5054569 block: Introduce ... |
351 352 353 354 355 356 357 |
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); } |
bf5054569 block: Introduce ... |
358 359 |
void blk_queue_free_zone_bitmaps(struct request_queue *q) { |
f216fdd77 block: replace se... |
360 361 |
kfree(q->conv_zones_bitmap); q->conv_zones_bitmap = NULL; |
bf5054569 block: Introduce ... |
362 363 364 |
kfree(q->seq_zones_wlock); q->seq_zones_wlock = NULL; } |
d41003513 block: rework zon... |
365 366 |
struct blk_revalidate_zone_args { struct gendisk *disk; |
f216fdd77 block: replace se... |
367 |
unsigned long *conv_zones_bitmap; |
d41003513 block: rework zon... |
368 |
unsigned long *seq_zones_wlock; |
e94f58194 block: allocate t... |
369 |
unsigned int nr_zones; |
6c6b35491 block: set the zo... |
370 |
sector_t zone_sectors; |
d41003513 block: rework zon... |
371 372 |
sector_t sector; }; |
d9dd73087 block: Enhance bl... |
373 374 375 |
/* * Helper function to check the validity of zones of a zoned block device. */ |
d41003513 block: rework zon... |
376 377 |
static int blk_revalidate_zone_cb(struct blk_zone *zone, unsigned int idx, void *data) |
d9dd73087 block: Enhance bl... |
378 |
{ |
d41003513 block: rework zon... |
379 380 |
struct blk_revalidate_zone_args *args = data; struct gendisk *disk = args->disk; |
d9dd73087 block: Enhance bl... |
381 |
struct request_queue *q = disk->queue; |
d9dd73087 block: Enhance bl... |
382 383 384 385 386 387 |
sector_t capacity = get_capacity(disk); /* * All zones must have the same size, with the exception on an eventual * smaller last zone. */ |
6c6b35491 block: set the zo... |
388 389 390 391 392 393 394 |
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) ", disk->disk_name, zone->len); return -ENODEV; } |
d9dd73087 block: Enhance bl... |
395 |
|
6c6b35491 block: set the zo... |
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 |
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 ", disk->disk_name); return -ENODEV; } } else { if (zone->len > args->zone_sectors) { pr_warn("%s: Invalid zoned device with larger last zone size ", disk->disk_name); return -ENODEV; } |
d9dd73087 block: Enhance bl... |
412 413 414 |
} /* Check for holes in the zone report */ |
d41003513 block: rework zon... |
415 |
if (zone->start != args->sector) { |
d9dd73087 block: Enhance bl... |
416 417 |
pr_warn("%s: Zone gap at sectors %llu..%llu ", |
d41003513 block: rework zon... |
418 419 |
disk->disk_name, args->sector, zone->start); return -ENODEV; |
d9dd73087 block: Enhance bl... |
420 421 422 423 424 |
} /* Check zone type */ switch (zone->type) { case BLK_ZONE_TYPE_CONVENTIONAL: |
e94f58194 block: allocate t... |
425 426 427 428 429 430 431 432 |
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; |
d9dd73087 block: Enhance bl... |
433 434 |
case BLK_ZONE_TYPE_SEQWRITE_REQ: case BLK_ZONE_TYPE_SEQWRITE_PREF: |
e94f58194 block: allocate t... |
435 436 437 438 439 440 |
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; } |
d9dd73087 block: Enhance bl... |
441 442 443 444 445 |
break; default: pr_warn("%s: Invalid zone type 0x%x at sectors %llu ", disk->disk_name, (int)zone->type, zone->start); |
d41003513 block: rework zon... |
446 |
return -ENODEV; |
d9dd73087 block: Enhance bl... |
447 |
} |
d41003513 block: rework zon... |
448 449 450 |
args->sector += zone->len; return 0; } |
bf5054569 block: Introduce ... |
451 452 453 |
/** * blk_revalidate_disk_zones - (re)allocate and initialize zone bitmaps * @disk: Target disk |
e732671aa block: Modify rev... |
454 |
* @update_driver_data: Callback to update driver data on the frozen disk |
bf5054569 block: Introduce ... |
455 456 457 |
* * Helper function for low-level device drivers to (re) allocate and initialize * a disk request queue zone bitmaps. This functions should normally be called |
ae58954d8 block: don't hand... |
458 459 460 |
* 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. |
e732671aa block: Modify rev... |
461 462 463 |
* 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. |
bf5054569 block: Introduce ... |
464 |
*/ |
e732671aa block: Modify rev... |
465 466 |
int blk_revalidate_disk_zones(struct gendisk *disk, void (*update_driver_data)(struct gendisk *disk)) |
bf5054569 block: Introduce ... |
467 468 |
{ struct request_queue *q = disk->queue; |
e94f58194 block: allocate t... |
469 470 |
struct blk_revalidate_zone_args args = { .disk = disk, |
e94f58194 block: allocate t... |
471 |
}; |
6c6b35491 block: set the zo... |
472 473 |
unsigned int noio_flag; int ret; |
bf5054569 block: Introduce ... |
474 |
|
c98c3d09f block: cleanup th... |
475 476 |
if (WARN_ON_ONCE(!blk_queue_is_zoned(q))) return -EIO; |
ae58954d8 block: don't hand... |
477 478 |
if (WARN_ON_ONCE(!queue_is_mq(q))) return -EIO; |
bf5054569 block: Introduce ... |
479 |
|
1a1206dc4 block: don't do r... |
480 481 |
if (!get_capacity(disk)) return -EIO; |
e94f58194 block: allocate t... |
482 |
/* |
6c6b35491 block: set the zo... |
483 484 |
* Ensure that all memory allocations in this context are done as if * GFP_NOIO was specified. |
e94f58194 block: allocate t... |
485 |
*/ |
6c6b35491 block: set the zo... |
486 487 488 489 |
noio_flag = memalloc_noio_save(); ret = disk->fops->report_zones(disk, 0, UINT_MAX, blk_revalidate_zone_cb, &args); memalloc_noio_restore(noio_flag); |
bf5054569 block: Introduce ... |
490 |
|
bf5054569 block: Introduce ... |
491 |
/* |
6c6b35491 block: set the zo... |
492 493 494 |
* 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). |
bf5054569 block: Introduce ... |
495 496 |
*/ blk_mq_freeze_queue(q); |
d41003513 block: rework zon... |
497 |
if (ret >= 0) { |
6c6b35491 block: set the zo... |
498 |
blk_queue_chunk_sectors(q, args.zone_sectors); |
e94f58194 block: allocate t... |
499 |
q->nr_zones = args.nr_zones; |
d41003513 block: rework zon... |
500 |
swap(q->seq_zones_wlock, args.seq_zones_wlock); |
f216fdd77 block: replace se... |
501 |
swap(q->conv_zones_bitmap, args.conv_zones_bitmap); |
e732671aa block: Modify rev... |
502 503 |
if (update_driver_data) update_driver_data(disk); |
d41003513 block: rework zon... |
504 505 |
ret = 0; } else { |
bf5054569 block: Introduce ... |
506 507 |
pr_warn("%s: failed to revalidate zones ", disk->disk_name); |
bf5054569 block: Introduce ... |
508 |
blk_queue_free_zone_bitmaps(q); |
bf5054569 block: Introduce ... |
509 |
} |
d41003513 block: rework zon... |
510 |
blk_mq_unfreeze_queue(q); |
bf5054569 block: Introduce ... |
511 |
|
d41003513 block: rework zon... |
512 |
kfree(args.seq_zones_wlock); |
f216fdd77 block: replace se... |
513 |
kfree(args.conv_zones_bitmap); |
bf5054569 block: Introduce ... |
514 515 516 |
return ret; } EXPORT_SYMBOL_GPL(blk_revalidate_disk_zones); |