1 // SPDX-License-Identifier: GPL-2.0
3 * Zoned block device handling
5 * Copyright (c) 2015, Hannes Reinecke
6 * Copyright (c) 2015, SUSE Linux GmbH
8 * Copyright (c) 2016, Damien Le Moal
9 * Copyright (c) 2016, Western Digital
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>
18 #include <linux/vmalloc.h>
19 #include <linux/sched/mm.h>
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
),
32 ZONE_COND_NAME(OFFLINE
),
37 * blk_zone_cond_str - Return string XXX in BLK_ZONE_COND_XXX.
38 * @zone_cond: BLK_ZONE_COND_XXX.
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".
44 const char *blk_zone_cond_str(enum blk_zone_cond zone_cond
)
46 static const char *zone_cond_str
= "UNKNOWN";
48 if (zone_cond
< ARRAY_SIZE(zone_cond_name
) && zone_cond_name
[zone_cond
])
49 zone_cond_str
= zone_cond_name
[zone_cond
];
53 EXPORT_SYMBOL_GPL(blk_zone_cond_str
);
56 * Return true if a request is a write requests that needs zone write locking.
58 bool blk_req_needs_zone_write_lock(struct request
*rq
)
60 if (!rq
->q
->disk
->seq_zones_wlock
)
63 return blk_rq_is_seq_zoned_write(rq
);
65 EXPORT_SYMBOL_GPL(blk_req_needs_zone_write_lock
);
67 bool blk_req_zone_write_trylock(struct request
*rq
)
69 unsigned int zno
= blk_rq_zone_no(rq
);
71 if (test_and_set_bit(zno
, rq
->q
->disk
->seq_zones_wlock
))
74 WARN_ON_ONCE(rq
->rq_flags
& RQF_ZONE_WRITE_LOCKED
);
75 rq
->rq_flags
|= RQF_ZONE_WRITE_LOCKED
;
79 EXPORT_SYMBOL_GPL(blk_req_zone_write_trylock
);
81 void __blk_req_zone_write_lock(struct request
*rq
)
83 if (WARN_ON_ONCE(test_and_set_bit(blk_rq_zone_no(rq
),
84 rq
->q
->disk
->seq_zones_wlock
)))
87 WARN_ON_ONCE(rq
->rq_flags
& RQF_ZONE_WRITE_LOCKED
);
88 rq
->rq_flags
|= RQF_ZONE_WRITE_LOCKED
;
90 EXPORT_SYMBOL_GPL(__blk_req_zone_write_lock
);
92 void __blk_req_zone_write_unlock(struct request
*rq
)
94 rq
->rq_flags
&= ~RQF_ZONE_WRITE_LOCKED
;
95 if (rq
->q
->disk
->seq_zones_wlock
)
96 WARN_ON_ONCE(!test_and_clear_bit(blk_rq_zone_no(rq
),
97 rq
->q
->disk
->seq_zones_wlock
));
99 EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock
);
102 * bdev_nr_zones - Get number of zones
103 * @bdev: Target device
105 * Return the total number of zones of a zoned block device. For a block
106 * device without zone capabilities, the number of zones is always 0.
108 unsigned int bdev_nr_zones(struct block_device
*bdev
)
110 sector_t zone_sectors
= bdev_zone_sectors(bdev
);
112 if (!bdev_is_zoned(bdev
))
114 return (bdev_nr_sectors(bdev
) + zone_sectors
- 1) >>
117 EXPORT_SYMBOL_GPL(bdev_nr_zones
);
120 * blkdev_report_zones - Get zones information
121 * @bdev: Target block device
122 * @sector: Sector from which to report zones
123 * @nr_zones: Maximum number of zones to report
124 * @cb: Callback function called for each reported zone
125 * @data: Private data for the callback
128 * Get zone information starting from the zone containing @sector for at most
129 * @nr_zones, and call @cb for each zone reported by the device.
130 * To report all zones in a device starting from @sector, the BLK_ALL_ZONES
131 * constant can be passed to @nr_zones.
132 * Returns the number of zones reported by the device, or a negative errno
133 * value in case of failure.
135 * Note: The caller must use memalloc_noXX_save/restore() calls to control
136 * memory allocations done within this function.
138 int blkdev_report_zones(struct block_device
*bdev
, sector_t sector
,
139 unsigned int nr_zones
, report_zones_cb cb
, void *data
)
141 struct gendisk
*disk
= bdev
->bd_disk
;
142 sector_t capacity
= get_capacity(disk
);
144 if (!bdev_is_zoned(bdev
) || WARN_ON_ONCE(!disk
->fops
->report_zones
))
147 if (!nr_zones
|| sector
>= capacity
)
150 return disk
->fops
->report_zones(disk
, sector
, nr_zones
, cb
, data
);
152 EXPORT_SYMBOL_GPL(blkdev_report_zones
);
154 static inline unsigned long *blk_alloc_zone_bitmap(int node
,
155 unsigned int nr_zones
)
157 return kcalloc_node(BITS_TO_LONGS(nr_zones
), sizeof(unsigned long),
161 static int blk_zone_need_reset_cb(struct blk_zone
*zone
, unsigned int idx
,
165 * For an all-zones reset, ignore conventional, empty, read-only
168 switch (zone
->cond
) {
169 case BLK_ZONE_COND_NOT_WP
:
170 case BLK_ZONE_COND_EMPTY
:
171 case BLK_ZONE_COND_READONLY
:
172 case BLK_ZONE_COND_OFFLINE
:
175 set_bit(idx
, (unsigned long *)data
);
180 static int blkdev_zone_reset_all_emulated(struct block_device
*bdev
,
183 struct gendisk
*disk
= bdev
->bd_disk
;
184 sector_t capacity
= bdev_nr_sectors(bdev
);
185 sector_t zone_sectors
= bdev_zone_sectors(bdev
);
186 unsigned long *need_reset
;
187 struct bio
*bio
= NULL
;
191 need_reset
= blk_alloc_zone_bitmap(disk
->queue
->node
, disk
->nr_zones
);
195 ret
= disk
->fops
->report_zones(disk
, 0, disk
->nr_zones
,
196 blk_zone_need_reset_cb
, need_reset
);
198 goto out_free_need_reset
;
201 while (sector
< capacity
) {
202 if (!test_bit(disk_zone_no(disk
, sector
), need_reset
)) {
203 sector
+= zone_sectors
;
207 bio
= blk_next_bio(bio
, bdev
, 0, REQ_OP_ZONE_RESET
| REQ_SYNC
,
209 bio
->bi_iter
.bi_sector
= sector
;
210 sector
+= zone_sectors
;
212 /* This may take a while, so be nice to others */
217 ret
= submit_bio_wait(bio
);
226 static int blkdev_zone_reset_all(struct block_device
*bdev
, gfp_t gfp_mask
)
230 bio_init(&bio
, bdev
, NULL
, 0, REQ_OP_ZONE_RESET_ALL
| REQ_SYNC
);
231 return submit_bio_wait(&bio
);
235 * blkdev_zone_mgmt - Execute a zone management operation on a range of zones
236 * @bdev: Target block device
237 * @op: Operation to be performed on the zones
238 * @sector: Start sector of the first zone to operate on
239 * @nr_sectors: Number of sectors, should be at least the length of one zone and
240 * must be zone size aligned.
241 * @gfp_mask: Memory allocation flags (for bio_alloc)
244 * Perform the specified operation on the range of zones specified by
245 * @sector..@sector+@nr_sectors. Specifying the entire disk sector range
246 * is valid, but the specified range should not contain conventional zones.
247 * The operation to execute on each zone can be a zone reset, open, close
250 int blkdev_zone_mgmt(struct block_device
*bdev
, enum req_op op
,
251 sector_t sector
, sector_t nr_sectors
, gfp_t gfp_mask
)
253 struct request_queue
*q
= bdev_get_queue(bdev
);
254 sector_t zone_sectors
= bdev_zone_sectors(bdev
);
255 sector_t capacity
= bdev_nr_sectors(bdev
);
256 sector_t end_sector
= sector
+ nr_sectors
;
257 struct bio
*bio
= NULL
;
260 if (!bdev_is_zoned(bdev
))
263 if (bdev_read_only(bdev
))
266 if (!op_is_zone_mgmt(op
))
269 if (end_sector
<= sector
|| end_sector
> capacity
)
273 /* Check alignment (handle eventual smaller last zone) */
274 if (!bdev_is_zone_start(bdev
, sector
))
277 if (!bdev_is_zone_start(bdev
, nr_sectors
) && end_sector
!= capacity
)
281 * In the case of a zone reset operation over all zones,
282 * REQ_OP_ZONE_RESET_ALL can be used with devices supporting this
283 * command. For other devices, we emulate this command behavior by
284 * identifying the zones needing a reset.
286 if (op
== REQ_OP_ZONE_RESET
&& sector
== 0 && nr_sectors
== capacity
) {
287 if (!blk_queue_zone_resetall(q
))
288 return blkdev_zone_reset_all_emulated(bdev
, gfp_mask
);
289 return blkdev_zone_reset_all(bdev
, gfp_mask
);
292 while (sector
< end_sector
) {
293 bio
= blk_next_bio(bio
, bdev
, 0, op
| REQ_SYNC
, gfp_mask
);
294 bio
->bi_iter
.bi_sector
= sector
;
295 sector
+= zone_sectors
;
297 /* This may take a while, so be nice to others */
301 ret
= submit_bio_wait(bio
);
306 EXPORT_SYMBOL_GPL(blkdev_zone_mgmt
);
308 struct zone_report_args
{
309 struct blk_zone __user
*zones
;
312 static int blkdev_copy_zone_to_user(struct blk_zone
*zone
, unsigned int idx
,
315 struct zone_report_args
*args
= data
;
317 if (copy_to_user(&args
->zones
[idx
], zone
, sizeof(struct blk_zone
)))
323 * BLKREPORTZONE ioctl processing.
324 * Called from blkdev_ioctl.
326 int blkdev_report_zones_ioctl(struct block_device
*bdev
, unsigned int cmd
,
329 void __user
*argp
= (void __user
*)arg
;
330 struct zone_report_args args
;
331 struct blk_zone_report rep
;
337 if (!bdev_is_zoned(bdev
))
340 if (copy_from_user(&rep
, argp
, sizeof(struct blk_zone_report
)))
346 args
.zones
= argp
+ sizeof(struct blk_zone_report
);
347 ret
= blkdev_report_zones(bdev
, rep
.sector
, rep
.nr_zones
,
348 blkdev_copy_zone_to_user
, &args
);
353 rep
.flags
= BLK_ZONE_REP_CAPACITY
;
354 if (copy_to_user(argp
, &rep
, sizeof(struct blk_zone_report
)))
359 static int blkdev_truncate_zone_range(struct block_device
*bdev
,
360 blk_mode_t mode
, const struct blk_zone_range
*zrange
)
364 if (zrange
->sector
+ zrange
->nr_sectors
<= zrange
->sector
||
365 zrange
->sector
+ zrange
->nr_sectors
> get_capacity(bdev
->bd_disk
))
369 start
= zrange
->sector
<< SECTOR_SHIFT
;
370 end
= ((zrange
->sector
+ zrange
->nr_sectors
) << SECTOR_SHIFT
) - 1;
372 return truncate_bdev_range(bdev
, mode
, start
, end
);
376 * BLKRESETZONE, BLKOPENZONE, BLKCLOSEZONE and BLKFINISHZONE ioctl processing.
377 * Called from blkdev_ioctl.
379 int blkdev_zone_mgmt_ioctl(struct block_device
*bdev
, blk_mode_t mode
,
380 unsigned int cmd
, unsigned long arg
)
382 void __user
*argp
= (void __user
*)arg
;
383 struct blk_zone_range zrange
;
390 if (!bdev_is_zoned(bdev
))
393 if (!(mode
& BLK_OPEN_WRITE
))
396 if (copy_from_user(&zrange
, argp
, sizeof(struct blk_zone_range
)))
401 op
= REQ_OP_ZONE_RESET
;
403 /* Invalidate the page cache, including dirty pages. */
404 filemap_invalidate_lock(bdev
->bd_inode
->i_mapping
);
405 ret
= blkdev_truncate_zone_range(bdev
, mode
, &zrange
);
410 op
= REQ_OP_ZONE_OPEN
;
413 op
= REQ_OP_ZONE_CLOSE
;
416 op
= REQ_OP_ZONE_FINISH
;
422 ret
= blkdev_zone_mgmt(bdev
, op
, zrange
.sector
, zrange
.nr_sectors
,
426 if (cmd
== BLKRESETZONE
)
427 filemap_invalidate_unlock(bdev
->bd_inode
->i_mapping
);
432 void disk_free_zone_bitmaps(struct gendisk
*disk
)
434 kfree(disk
->conv_zones_bitmap
);
435 disk
->conv_zones_bitmap
= NULL
;
436 kfree(disk
->seq_zones_wlock
);
437 disk
->seq_zones_wlock
= NULL
;
440 struct blk_revalidate_zone_args
{
441 struct gendisk
*disk
;
442 unsigned long *conv_zones_bitmap
;
443 unsigned long *seq_zones_wlock
;
444 unsigned int nr_zones
;
449 * Helper function to check the validity of zones of a zoned block device.
451 static int blk_revalidate_zone_cb(struct blk_zone
*zone
, unsigned int idx
,
454 struct blk_revalidate_zone_args
*args
= data
;
455 struct gendisk
*disk
= args
->disk
;
456 struct request_queue
*q
= disk
->queue
;
457 sector_t capacity
= get_capacity(disk
);
458 sector_t zone_sectors
= q
->limits
.chunk_sectors
;
460 /* Check for bad zones and holes in the zone report */
461 if (zone
->start
!= args
->sector
) {
462 pr_warn("%s: Zone gap at sectors %llu..%llu\n",
463 disk
->disk_name
, args
->sector
, zone
->start
);
467 if (zone
->start
>= capacity
|| !zone
->len
) {
468 pr_warn("%s: Invalid zone start %llu, length %llu\n",
469 disk
->disk_name
, zone
->start
, zone
->len
);
474 * All zones must have the same size, with the exception on an eventual
477 if (zone
->start
+ zone
->len
< capacity
) {
478 if (zone
->len
!= zone_sectors
) {
479 pr_warn("%s: Invalid zoned device with non constant zone size\n",
483 } else if (zone
->len
> zone_sectors
) {
484 pr_warn("%s: Invalid zoned device with larger last zone size\n",
489 /* Check zone type */
490 switch (zone
->type
) {
491 case BLK_ZONE_TYPE_CONVENTIONAL
:
492 if (!args
->conv_zones_bitmap
) {
493 args
->conv_zones_bitmap
=
494 blk_alloc_zone_bitmap(q
->node
, args
->nr_zones
);
495 if (!args
->conv_zones_bitmap
)
498 set_bit(idx
, args
->conv_zones_bitmap
);
500 case BLK_ZONE_TYPE_SEQWRITE_REQ
:
501 case BLK_ZONE_TYPE_SEQWRITE_PREF
:
502 if (!args
->seq_zones_wlock
) {
503 args
->seq_zones_wlock
=
504 blk_alloc_zone_bitmap(q
->node
, args
->nr_zones
);
505 if (!args
->seq_zones_wlock
)
510 pr_warn("%s: Invalid zone type 0x%x at sectors %llu\n",
511 disk
->disk_name
, (int)zone
->type
, zone
->start
);
515 args
->sector
+= zone
->len
;
520 * blk_revalidate_disk_zones - (re)allocate and initialize zone bitmaps
522 * @update_driver_data: Callback to update driver data on the frozen disk
524 * Helper function for low-level device drivers to check and (re) allocate and
525 * initialize a disk request queue zone bitmaps. This functions should normally
526 * be called within the disk ->revalidate method for blk-mq based drivers.
527 * Before calling this function, the device driver must already have set the
528 * device zone size (chunk_sector limit) and the max zone append limit.
529 * For BIO based drivers, this function cannot be used. BIO based device drivers
530 * only need to set disk->nr_zones so that the sysfs exposed value is correct.
531 * If the @update_driver_data callback function is not NULL, the callback is
532 * executed with the device request queue frozen after all zones have been
535 int blk_revalidate_disk_zones(struct gendisk
*disk
,
536 void (*update_driver_data
)(struct gendisk
*disk
))
538 struct request_queue
*q
= disk
->queue
;
539 sector_t zone_sectors
= q
->limits
.chunk_sectors
;
540 sector_t capacity
= get_capacity(disk
);
541 struct blk_revalidate_zone_args args
= { };
542 unsigned int noio_flag
;
545 if (WARN_ON_ONCE(!blk_queue_is_zoned(q
)))
547 if (WARN_ON_ONCE(!queue_is_mq(q
)))
554 * Checks that the device driver indicated a valid zone size and that
555 * the max zone append limit is set.
557 if (!zone_sectors
|| !is_power_of_2(zone_sectors
)) {
558 pr_warn("%s: Invalid non power of two zone size (%llu)\n",
559 disk
->disk_name
, zone_sectors
);
563 if (!q
->limits
.max_zone_append_sectors
) {
564 pr_warn("%s: Invalid 0 maximum zone append limit\n",
570 * Ensure that all memory allocations in this context are done as if
571 * GFP_NOIO was specified.
574 args
.nr_zones
= (capacity
+ zone_sectors
- 1) >> ilog2(zone_sectors
);
575 noio_flag
= memalloc_noio_save();
576 ret
= disk
->fops
->report_zones(disk
, 0, UINT_MAX
,
577 blk_revalidate_zone_cb
, &args
);
579 pr_warn("%s: No zones reported\n", disk
->disk_name
);
582 memalloc_noio_restore(noio_flag
);
585 * If zones where reported, make sure that the entire disk capacity
588 if (ret
> 0 && args
.sector
!= capacity
) {
589 pr_warn("%s: Missing zones from sector %llu\n",
590 disk
->disk_name
, args
.sector
);
595 * Install the new bitmaps and update nr_zones only once the queue is
596 * stopped and all I/Os are completed (i.e. a scheduler is not
597 * referencing the bitmaps).
599 blk_mq_freeze_queue(q
);
601 disk
->nr_zones
= args
.nr_zones
;
602 swap(disk
->seq_zones_wlock
, args
.seq_zones_wlock
);
603 swap(disk
->conv_zones_bitmap
, args
.conv_zones_bitmap
);
604 if (update_driver_data
)
605 update_driver_data(disk
);
608 pr_warn("%s: failed to revalidate zones\n", disk
->disk_name
);
609 disk_free_zone_bitmaps(disk
);
611 blk_mq_unfreeze_queue(q
);
613 kfree(args
.seq_zones_wlock
);
614 kfree(args
.conv_zones_bitmap
);
617 EXPORT_SYMBOL_GPL(blk_revalidate_disk_zones
);
619 void disk_clear_zone_settings(struct gendisk
*disk
)
621 struct request_queue
*q
= disk
->queue
;
623 blk_mq_freeze_queue(q
);
625 disk_free_zone_bitmaps(disk
);
626 blk_queue_flag_clear(QUEUE_FLAG_ZONE_RESETALL
, q
);
627 q
->required_elevator_features
&= ~ELEVATOR_F_ZBD_SEQ_WRITE
;
629 disk
->max_open_zones
= 0;
630 disk
->max_active_zones
= 0;
631 q
->limits
.chunk_sectors
= 0;
632 q
->limits
.zone_write_granularity
= 0;
633 q
->limits
.max_zone_append_sectors
= 0;
635 blk_mq_unfreeze_queue(q
);