1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Zoned block device handling
4 *
5 * Copyright (c) 2015, Hannes Reinecke
6 * Copyright (c) 2015, SUSE Linux GmbH
7 *
8 * Copyright (c) 2016, Damien Le Moal
9 * Copyright (c) 2016, Western Digital
10 */
11
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/rbtree.h>
15 #include <linux/blkdev.h>
16 #include <linux/blk-mq.h>
17 #include <linux/mm.h>
18 #include <linux/vmalloc.h>
19 #include <linux/sched/mm.h>
20
21 #include "blk.h"
22
23 #define ZONE_COND_NAME(name) [BLK_ZONE_COND_##name] = #name
24 static const char *const zone_cond_name[] = {
25 ZONE_COND_NAME(NOT_WP),
26 ZONE_COND_NAME(EMPTY),
27 ZONE_COND_NAME(IMP_OPEN),
28 ZONE_COND_NAME(EXP_OPEN),
29 ZONE_COND_NAME(CLOSED),
30 ZONE_COND_NAME(READONLY),
31 ZONE_COND_NAME(FULL),
32 ZONE_COND_NAME(OFFLINE),
33 };
34 #undef ZONE_COND_NAME
35
36 /**
37 * blk_zone_cond_str - Return string XXX in BLK_ZONE_COND_XXX.
38 * @zone_cond: BLK_ZONE_COND_XXX.
39 *
40 * Description: Centralize block layer function to convert BLK_ZONE_COND_XXX
41 * into string format. Useful in the debugging and tracing zone conditions. For
42 * invalid BLK_ZONE_COND_XXX it returns string "UNKNOWN".
43 */
blk_zone_cond_str(enum blk_zone_cond zone_cond)44 const char *blk_zone_cond_str(enum blk_zone_cond zone_cond)
45 {
46 static const char *zone_cond_str = "UNKNOWN";
47
48 if (zone_cond < ARRAY_SIZE(zone_cond_name) && zone_cond_name[zone_cond])
49 zone_cond_str = zone_cond_name[zone_cond];
50
51 return zone_cond_str;
52 }
53 EXPORT_SYMBOL_GPL(blk_zone_cond_str);
54
55 /*
56 * Return true if a request is a write requests that needs zone write locking.
57 */
blk_req_needs_zone_write_lock(struct request * rq)58 bool blk_req_needs_zone_write_lock(struct request *rq)
59 {
60 return rq->q->seq_zones_wlock && blk_rq_is_seq_zoned_write(rq);
61 }
62 EXPORT_SYMBOL_GPL(blk_req_needs_zone_write_lock);
63
blk_req_zone_write_trylock(struct request * rq)64 bool blk_req_zone_write_trylock(struct request *rq)
65 {
66 unsigned int zno = blk_rq_zone_no(rq);
67
68 if (test_and_set_bit(zno, rq->q->seq_zones_wlock))
69 return false;
70
71 WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
72 rq->rq_flags |= RQF_ZONE_WRITE_LOCKED;
73
74 return true;
75 }
76 EXPORT_SYMBOL_GPL(blk_req_zone_write_trylock);
77
__blk_req_zone_write_lock(struct request * rq)78 void __blk_req_zone_write_lock(struct request *rq)
79 {
80 if (WARN_ON_ONCE(test_and_set_bit(blk_rq_zone_no(rq),
81 rq->q->seq_zones_wlock)))
82 return;
83
84 WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
85 rq->rq_flags |= RQF_ZONE_WRITE_LOCKED;
86 }
87 EXPORT_SYMBOL_GPL(__blk_req_zone_write_lock);
88
__blk_req_zone_write_unlock(struct request * rq)89 void __blk_req_zone_write_unlock(struct request *rq)
90 {
91 rq->rq_flags &= ~RQF_ZONE_WRITE_LOCKED;
92 if (rq->q->seq_zones_wlock)
93 WARN_ON_ONCE(!test_and_clear_bit(blk_rq_zone_no(rq),
94 rq->q->seq_zones_wlock));
95 }
96 EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock);
97
98 /**
99 * blkdev_nr_zones - Get number of zones
100 * @disk: Target gendisk
101 *
102 * Return the total number of zones of a zoned block device, including the
103 * eventual small last zone if present. For a block device without zone
104 * capabilities, the number of zones is always 0.
105 */
blkdev_nr_zones(struct gendisk * disk)106 unsigned int blkdev_nr_zones(struct gendisk *disk)
107 {
108 sector_t zone_sectors = blk_queue_zone_sectors(disk->queue);
109 sector_t capacity = get_capacity(disk);
110
111 if (!blk_queue_is_zoned(disk->queue))
112 return 0;
113
114 if (is_power_of_2(zone_sectors))
115 return (capacity + zone_sectors - 1) >> ilog2(zone_sectors);
116
117 return DIV_ROUND_UP_SECTOR_T(capacity, zone_sectors);
118 }
119 EXPORT_SYMBOL_GPL(blkdev_nr_zones);
120
121 /**
122 * blkdev_report_zones - Get zones information
123 * @bdev: Target block device
124 * @sector: Sector from which to report zones
125 * @nr_zones: Maximum number of zones to report
126 * @cb: Callback function called for each reported zone
127 * @data: Private data for the callback
128 *
129 * Description:
130 * Get zone information starting from the zone containing @sector for at most
131 * @nr_zones, and call @cb for each zone reported by the device.
132 * To report all zones in a device starting from @sector, the BLK_ALL_ZONES
133 * constant can be passed to @nr_zones.
134 * Returns the number of zones reported by the device, or a negative errno
135 * value in case of failure.
136 *
137 * Note: The caller must use memalloc_noXX_save/restore() calls to control
138 * memory allocations done within this function.
139 */
blkdev_report_zones(struct block_device * bdev,sector_t sector,unsigned int nr_zones,report_zones_cb cb,void * data)140 int blkdev_report_zones(struct block_device *bdev, sector_t sector,
141 unsigned int nr_zones, report_zones_cb cb, void *data)
142 {
143 struct gendisk *disk = bdev->bd_disk;
144 sector_t capacity = get_capacity(disk);
145
146 if (!blk_queue_is_zoned(bdev_get_queue(bdev)) ||
147 WARN_ON_ONCE(!disk->fops->report_zones))
148 return -EOPNOTSUPP;
149
150 if (!nr_zones || sector >= capacity)
151 return 0;
152
153 return disk->fops->report_zones(disk, sector, nr_zones, cb, data);
154 }
155 EXPORT_SYMBOL_GPL(blkdev_report_zones);
156
blk_alloc_zone_bitmap(int node,unsigned int nr_zones)157 static inline unsigned long *blk_alloc_zone_bitmap(int node,
158 unsigned int nr_zones)
159 {
160 return kcalloc_node(BITS_TO_LONGS(nr_zones), sizeof(unsigned long),
161 GFP_NOIO, node);
162 }
163
blk_zone_need_reset_cb(struct blk_zone * zone,unsigned int idx,void * data)164 static int blk_zone_need_reset_cb(struct blk_zone *zone, unsigned int idx,
165 void *data)
166 {
167 /*
168 * For an all-zones reset, ignore conventional, empty, read-only
169 * and offline zones.
170 */
171 switch (zone->cond) {
172 case BLK_ZONE_COND_NOT_WP:
173 case BLK_ZONE_COND_EMPTY:
174 case BLK_ZONE_COND_READONLY:
175 case BLK_ZONE_COND_OFFLINE:
176 return 0;
177 default:
178 set_bit(idx, (unsigned long *)data);
179 return 0;
180 }
181 }
182
blkdev_zone_reset_all_emulated(struct block_device * bdev,gfp_t gfp_mask)183 static int blkdev_zone_reset_all_emulated(struct block_device *bdev,
184 gfp_t gfp_mask)
185 {
186 struct request_queue *q = bdev_get_queue(bdev);
187 sector_t capacity = get_capacity(bdev->bd_disk);
188 sector_t zone_sectors = blk_queue_zone_sectors(q);
189 unsigned long *need_reset;
190 struct bio *bio = NULL;
191 sector_t sector = 0;
192 int ret;
193
194 need_reset = blk_alloc_zone_bitmap(q->node, q->nr_zones);
195 if (!need_reset)
196 return -ENOMEM;
197
198 ret = bdev->bd_disk->fops->report_zones(bdev->bd_disk, 0,
199 q->nr_zones, blk_zone_need_reset_cb,
200 need_reset);
201 if (ret < 0)
202 goto out_free_need_reset;
203
204 ret = 0;
205 while (sector < capacity) {
206 if (!test_bit(blk_queue_zone_no(q, sector), need_reset)) {
207 sector += zone_sectors;
208 continue;
209 }
210
211 bio = blk_next_bio(bio, 0, gfp_mask);
212 bio_set_dev(bio, bdev);
213 bio->bi_opf = REQ_OP_ZONE_RESET | REQ_SYNC;
214 bio->bi_iter.bi_sector = sector;
215 sector += zone_sectors;
216
217 /* This may take a while, so be nice to others */
218 cond_resched();
219 }
220
221 if (bio) {
222 ret = submit_bio_wait(bio);
223 bio_put(bio);
224 }
225
226 out_free_need_reset:
227 kfree(need_reset);
228 return ret;
229 }
230
blkdev_zone_reset_all(struct block_device * bdev,gfp_t gfp_mask)231 static int blkdev_zone_reset_all(struct block_device *bdev, gfp_t gfp_mask)
232 {
233 struct bio bio;
234
235 bio_init(&bio, NULL, 0);
236 bio_set_dev(&bio, bdev);
237 bio.bi_opf = REQ_OP_ZONE_RESET_ALL | REQ_SYNC;
238
239 return submit_bio_wait(&bio);
240 }
241
242 /**
243 * blkdev_zone_mgmt - Execute a zone management operation on a range of zones
244 * @bdev: Target block device
245 * @op: Operation to be performed on the zones
246 * @sector: Start sector of the first zone to operate on
247 * @nr_sectors: Number of sectors, should be at least the length of one zone and
248 * must be zone size aligned.
249 * @gfp_mask: Memory allocation flags (for bio_alloc)
250 *
251 * Description:
252 * Perform the specified operation on the range of zones specified by
253 * @sector..@sector+@nr_sectors. Specifying the entire disk sector range
254 * is valid, but the specified range should not contain conventional zones.
255 * The operation to execute on each zone can be a zone reset, open, close
256 * or finish request.
257 */
blkdev_zone_mgmt(struct block_device * bdev,enum req_opf op,sector_t sector,sector_t nr_sectors,gfp_t gfp_mask)258 int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
259 sector_t sector, sector_t nr_sectors,
260 gfp_t gfp_mask)
261 {
262 struct request_queue *q = bdev_get_queue(bdev);
263 sector_t zone_sectors = blk_queue_zone_sectors(q);
264 sector_t capacity = get_capacity(bdev->bd_disk);
265 sector_t end_sector = sector + nr_sectors;
266 struct bio *bio = NULL;
267 int ret = 0;
268
269 if (!blk_queue_is_zoned(q))
270 return -EOPNOTSUPP;
271
272 if (bdev_read_only(bdev))
273 return -EPERM;
274
275 if (!op_is_zone_mgmt(op))
276 return -EOPNOTSUPP;
277
278 if (end_sector <= sector || end_sector > capacity)
279 /* Out of range */
280 return -EINVAL;
281
282 /* Check alignment (handle eventual smaller last zone) */
283 if (!bdev_is_zone_start(bdev, sector))
284 return -EINVAL;
285
286 if (!bdev_is_zone_start(bdev, nr_sectors) && end_sector != capacity)
287 return -EINVAL;
288
289 /*
290 * In the case of a zone reset operation over all zones,
291 * REQ_OP_ZONE_RESET_ALL can be used with devices supporting this
292 * command. For other devices, we emulate this command behavior by
293 * identifying the zones needing a reset.
294 */
295 if (op == REQ_OP_ZONE_RESET && sector == 0 && nr_sectors == capacity) {
296 if (!blk_queue_zone_resetall(q))
297 return blkdev_zone_reset_all_emulated(bdev, gfp_mask);
298 return blkdev_zone_reset_all(bdev, gfp_mask);
299 }
300
301 while (sector < end_sector) {
302 bio = blk_next_bio(bio, 0, gfp_mask);
303 bio_set_dev(bio, bdev);
304 bio->bi_opf = op | REQ_SYNC;
305 bio->bi_iter.bi_sector = sector;
306 sector += zone_sectors;
307
308 /* This may take a while, so be nice to others */
309 cond_resched();
310 }
311
312 ret = submit_bio_wait(bio);
313 bio_put(bio);
314
315 return ret;
316 }
317 EXPORT_SYMBOL_GPL(blkdev_zone_mgmt);
318
319 struct zone_report_args {
320 struct blk_zone __user *zones;
321 };
322
blkdev_copy_zone_to_user(struct blk_zone * zone,unsigned int idx,void * data)323 static int blkdev_copy_zone_to_user(struct blk_zone *zone, unsigned int idx,
324 void *data)
325 {
326 struct zone_report_args *args = data;
327
328 if (copy_to_user(&args->zones[idx], zone, sizeof(struct blk_zone)))
329 return -EFAULT;
330 return 0;
331 }
332
333 /*
334 * BLKREPORTZONE ioctl processing.
335 * Called from blkdev_ioctl.
336 */
blkdev_report_zones_ioctl(struct block_device * bdev,fmode_t mode,unsigned int cmd,unsigned long arg)337 int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
338 unsigned int cmd, unsigned long arg)
339 {
340 void __user *argp = (void __user *)arg;
341 struct zone_report_args args;
342 struct request_queue *q;
343 struct blk_zone_report rep;
344 int ret;
345
346 if (!argp)
347 return -EINVAL;
348
349 q = bdev_get_queue(bdev);
350 if (!q)
351 return -ENXIO;
352
353 if (!blk_queue_is_zoned(q))
354 return -ENOTTY;
355
356 if (copy_from_user(&rep, argp, sizeof(struct blk_zone_report)))
357 return -EFAULT;
358
359 if (!rep.nr_zones)
360 return -EINVAL;
361
362 args.zones = argp + sizeof(struct blk_zone_report);
363 ret = blkdev_report_zones(bdev, rep.sector, rep.nr_zones,
364 blkdev_copy_zone_to_user, &args);
365 if (ret < 0)
366 return ret;
367
368 rep.nr_zones = ret;
369 rep.flags = BLK_ZONE_REP_CAPACITY;
370 if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report)))
371 return -EFAULT;
372 return 0;
373 }
374
blkdev_truncate_zone_range(struct block_device * bdev,fmode_t mode,const struct blk_zone_range * zrange)375 static int blkdev_truncate_zone_range(struct block_device *bdev, fmode_t mode,
376 const struct blk_zone_range *zrange)
377 {
378 loff_t start, end;
379
380 if (zrange->sector + zrange->nr_sectors <= zrange->sector ||
381 zrange->sector + zrange->nr_sectors > get_capacity(bdev->bd_disk))
382 /* Out of range */
383 return -EINVAL;
384
385 start = zrange->sector << SECTOR_SHIFT;
386 end = ((zrange->sector + zrange->nr_sectors) << SECTOR_SHIFT) - 1;
387
388 return truncate_bdev_range(bdev, mode, start, end);
389 }
390
391 /*
392 * BLKRESETZONE, BLKOPENZONE, BLKCLOSEZONE and BLKFINISHZONE ioctl processing.
393 * Called from blkdev_ioctl.
394 */
blkdev_zone_mgmt_ioctl(struct block_device * bdev,fmode_t mode,unsigned int cmd,unsigned long arg)395 int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode,
396 unsigned int cmd, unsigned long arg)
397 {
398 void __user *argp = (void __user *)arg;
399 struct request_queue *q;
400 struct blk_zone_range zrange;
401 enum req_opf op;
402 int ret;
403
404 if (!argp)
405 return -EINVAL;
406
407 q = bdev_get_queue(bdev);
408 if (!q)
409 return -ENXIO;
410
411 if (!blk_queue_is_zoned(q))
412 return -ENOTTY;
413
414 if (!(mode & FMODE_WRITE))
415 return -EBADF;
416
417 if (copy_from_user(&zrange, argp, sizeof(struct blk_zone_range)))
418 return -EFAULT;
419
420 switch (cmd) {
421 case BLKRESETZONE:
422 op = REQ_OP_ZONE_RESET;
423
424 /* Invalidate the page cache, including dirty pages. */
425 filemap_invalidate_lock(bdev->bd_inode->i_mapping);
426 ret = blkdev_truncate_zone_range(bdev, mode, &zrange);
427 if (ret)
428 goto fail;
429 break;
430 case BLKOPENZONE:
431 op = REQ_OP_ZONE_OPEN;
432 break;
433 case BLKCLOSEZONE:
434 op = REQ_OP_ZONE_CLOSE;
435 break;
436 case BLKFINISHZONE:
437 op = REQ_OP_ZONE_FINISH;
438 break;
439 default:
440 return -ENOTTY;
441 }
442
443 ret = blkdev_zone_mgmt(bdev, op, zrange.sector, zrange.nr_sectors,
444 GFP_KERNEL);
445
446 fail:
447 if (cmd == BLKRESETZONE)
448 filemap_invalidate_unlock(bdev->bd_inode->i_mapping);
449
450 return ret;
451 }
452
blk_queue_free_zone_bitmaps(struct request_queue * q)453 void blk_queue_free_zone_bitmaps(struct request_queue *q)
454 {
455 kfree(q->conv_zones_bitmap);
456 q->conv_zones_bitmap = NULL;
457 kfree(q->seq_zones_wlock);
458 q->seq_zones_wlock = NULL;
459 }
460
461 struct blk_revalidate_zone_args {
462 struct gendisk *disk;
463 unsigned long *conv_zones_bitmap;
464 unsigned long *seq_zones_wlock;
465 unsigned int nr_zones;
466 sector_t zone_sectors;
467 sector_t sector;
468 };
469
470 /*
471 * Helper function to check the validity of zones of a zoned block device.
472 */
blk_revalidate_zone_cb(struct blk_zone * zone,unsigned int idx,void * data)473 static int blk_revalidate_zone_cb(struct blk_zone *zone, unsigned int idx,
474 void *data)
475 {
476 struct blk_revalidate_zone_args *args = data;
477 struct gendisk *disk = args->disk;
478 struct request_queue *q = disk->queue;
479 sector_t capacity = get_capacity(disk);
480
481 /*
482 * All zones must have the same size, with the exception on an eventual
483 * smaller last zone.
484 */
485 if (zone->start == 0) {
486 if (zone->len == 0) {
487 pr_warn("%s: Invalid zero zone size", disk->disk_name);
488 return -ENODEV;
489 }
490
491 /*
492 * Non power-of-2 zone size support was added to remove the
493 * gap between zone capacity and zone size. Though it is technically
494 * possible to have gaps in a non power-of-2 device, Linux requires
495 * the zone size to be equal to zone capacity for non power-of-2
496 * zoned devices.
497 */
498 if (!is_power_of_2(zone->len) && zone->capacity < zone->len) {
499 pr_err("%s: Invalid zone capacity %lld with non power-of-2 zone size %lld",
500 disk->disk_name, zone->capacity, zone->len);
501 return -ENODEV;
502 }
503
504 args->zone_sectors = zone->len;
505 args->nr_zones = div64_u64(capacity + zone->len - 1, zone->len);
506 } else if (zone->start + args->zone_sectors < capacity) {
507 if (zone->len != args->zone_sectors) {
508 pr_warn("%s: Invalid zoned device with non constant zone size\n",
509 disk->disk_name);
510 return -ENODEV;
511 }
512 } else {
513 if (zone->len > args->zone_sectors) {
514 pr_warn("%s: Invalid zoned device with larger last zone size\n",
515 disk->disk_name);
516 return -ENODEV;
517 }
518 }
519
520 /* Check for holes in the zone report */
521 if (zone->start != args->sector) {
522 pr_warn("%s: Zone gap at sectors %llu..%llu\n",
523 disk->disk_name, args->sector, zone->start);
524 return -ENODEV;
525 }
526
527 /* Check zone type */
528 switch (zone->type) {
529 case BLK_ZONE_TYPE_CONVENTIONAL:
530 if (!args->conv_zones_bitmap) {
531 args->conv_zones_bitmap =
532 blk_alloc_zone_bitmap(q->node, args->nr_zones);
533 if (!args->conv_zones_bitmap)
534 return -ENOMEM;
535 }
536 set_bit(idx, args->conv_zones_bitmap);
537 break;
538 case BLK_ZONE_TYPE_SEQWRITE_REQ:
539 case BLK_ZONE_TYPE_SEQWRITE_PREF:
540 if (!args->seq_zones_wlock) {
541 args->seq_zones_wlock =
542 blk_alloc_zone_bitmap(q->node, args->nr_zones);
543 if (!args->seq_zones_wlock)
544 return -ENOMEM;
545 }
546 break;
547 default:
548 pr_warn("%s: Invalid zone type 0x%x at sectors %llu\n",
549 disk->disk_name, (int)zone->type, zone->start);
550 return -ENODEV;
551 }
552
553 args->sector += zone->len;
554 return 0;
555 }
556
557 /**
558 * blk_revalidate_disk_zones - (re)allocate and initialize zone bitmaps
559 * @disk: Target disk
560 * @update_driver_data: Callback to update driver data on the frozen disk
561 *
562 * Helper function for low-level device drivers to (re) allocate and initialize
563 * a disk request queue zone bitmaps. This functions should normally be called
564 * within the disk ->revalidate method for blk-mq based drivers. For BIO based
565 * drivers only q->nr_zones needs to be updated so that the sysfs exposed value
566 * is correct.
567 * If the @update_driver_data callback function is not NULL, the callback is
568 * executed with the device request queue frozen after all zones have been
569 * checked.
570 */
blk_revalidate_disk_zones(struct gendisk * disk,void (* update_driver_data)(struct gendisk * disk))571 int blk_revalidate_disk_zones(struct gendisk *disk,
572 void (*update_driver_data)(struct gendisk *disk))
573 {
574 struct request_queue *q = disk->queue;
575 struct blk_revalidate_zone_args args = {
576 .disk = disk,
577 };
578 unsigned int noio_flag;
579 int ret;
580
581 if (WARN_ON_ONCE(!blk_queue_is_zoned(q)))
582 return -EIO;
583 if (WARN_ON_ONCE(!queue_is_mq(q)))
584 return -EIO;
585
586 if (!get_capacity(disk))
587 return -EIO;
588
589 /*
590 * Ensure that all memory allocations in this context are done as if
591 * GFP_NOIO was specified.
592 */
593 noio_flag = memalloc_noio_save();
594 ret = disk->fops->report_zones(disk, 0, UINT_MAX,
595 blk_revalidate_zone_cb, &args);
596 if (!ret) {
597 pr_warn("%s: No zones reported\n", disk->disk_name);
598 ret = -ENODEV;
599 }
600 memalloc_noio_restore(noio_flag);
601
602 /*
603 * If zones where reported, make sure that the entire disk capacity
604 * has been checked.
605 */
606 if (ret > 0 && args.sector != get_capacity(disk)) {
607 pr_warn("%s: Missing zones from sector %llu\n",
608 disk->disk_name, args.sector);
609 ret = -ENODEV;
610 }
611
612 /*
613 * Install the new bitmaps and update nr_zones only once the queue is
614 * stopped and all I/Os are completed (i.e. a scheduler is not
615 * referencing the bitmaps).
616 */
617 blk_mq_freeze_queue(q);
618 if (ret > 0) {
619 blk_queue_chunk_sectors(q, args.zone_sectors);
620 q->nr_zones = args.nr_zones;
621 swap(q->seq_zones_wlock, args.seq_zones_wlock);
622 swap(q->conv_zones_bitmap, args.conv_zones_bitmap);
623 if (update_driver_data)
624 update_driver_data(disk);
625 ret = 0;
626 } else {
627 pr_warn("%s: failed to revalidate zones\n", disk->disk_name);
628 blk_queue_free_zone_bitmaps(q);
629 }
630 blk_mq_unfreeze_queue(q);
631
632 kfree(args.seq_zones_wlock);
633 kfree(args.conv_zones_bitmap);
634 return ret;
635 }
636 EXPORT_SYMBOL_GPL(blk_revalidate_disk_zones);
637
blk_queue_clear_zone_settings(struct request_queue * q)638 void blk_queue_clear_zone_settings(struct request_queue *q)
639 {
640 blk_mq_freeze_queue(q);
641
642 blk_queue_free_zone_bitmaps(q);
643 blk_queue_flag_clear(QUEUE_FLAG_ZONE_RESETALL, q);
644 q->required_elevator_features &= ~ELEVATOR_F_ZBD_SEQ_WRITE;
645 q->nr_zones = 0;
646 q->max_open_zones = 0;
647 q->max_active_zones = 0;
648 q->limits.chunk_sectors = 0;
649 q->limits.zone_write_granularity = 0;
650 q->limits.max_zone_append_sectors = 0;
651
652 blk_mq_unfreeze_queue(q);
653 }
654