forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-11 1f93a7dfd1f8d5ff7a5c53246c7534fe2332d6f4 
 kernel/block/blk-zoned.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0
12 /*
23  * Zoned block device handling
34  *
....@@ -12,6 +13,44 @@
1213 #include <linux/module.h>
1314 #include <linux/rbtree.h>
1415 #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
+ */
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);
1554 
1655 static inline sector_t blk_zone_start(struct request_queue *q,
1756 				      sector_t sector)
....@@ -43,6 +82,20 @@
4382 }
4483 EXPORT_SYMBOL_GPL(blk_req_needs_zone_write_lock);
4584 
85
+bool blk_req_zone_write_trylock(struct request *rq)
86
+{
87
+	unsigned int zno = blk_rq_zone_no(rq);
88
+
89
+	if (test_and_set_bit(zno, rq->q->seq_zones_wlock))
90
+		return false;
91
+
92
+	WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
93
+	rq->rq_flags |= RQF_ZONE_WRITE_LOCKED;
94
+
95
+	return true;
96
+}
97
+EXPORT_SYMBOL_GPL(blk_req_zone_write_trylock);
98
+
4699 void __blk_req_zone_write_lock(struct request *rq)
47100 {
48101 	if (WARN_ON_ONCE(test_and_set_bit(blk_rq_zone_no(rq),
....@@ -63,238 +116,162 @@
63116 }
64117 EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock);
65118 
66
-/*
67
- * Check that a zone report belongs to the partition.
68
- * If yes, fix its start sector and write pointer, copy it in the
69
- * zone information array and return true. Return false otherwise.
119
+/**
120
+ * blkdev_nr_zones - Get number of zones
121
+ * @disk:	Target gendisk
122
+ *
123
+ * Return the total number of zones of a zoned block device.  For a block
124
+ * device without zone capabilities, the number of zones is always 0.
70125  */
71
-static bool blkdev_report_zone(struct block_device *bdev,
72
-			       struct blk_zone *rep,
73
-			       struct blk_zone *zone)
126
+unsigned int blkdev_nr_zones(struct gendisk *disk)
74127 {
75
-	sector_t offset = get_start_sect(bdev);
128
+	sector_t zone_sectors = blk_queue_zone_sectors(disk->queue);
76129 
77
-	if (rep->start < offset)
78
-		return false;
79
-
80
-	rep->start -= offset;
81
-	if (rep->start + rep->len > bdev->bd_part->nr_sects)
82
-		return false;
83
-
84
-	if (rep->type == BLK_ZONE_TYPE_CONVENTIONAL)
85
-		rep->wp = rep->start + rep->len;
86
-	else
87
-		rep->wp -= offset;
88
-	memcpy(zone, rep, sizeof(struct blk_zone));
89
-
90
-	return true;
130
+	if (!blk_queue_is_zoned(disk->queue))
131
+		return 0;
132
+	return (get_capacity(disk) + zone_sectors - 1) >> ilog2(zone_sectors);
91133 }
134
+EXPORT_SYMBOL_GPL(blkdev_nr_zones);
92135 
93136 /**
94137  * blkdev_report_zones - Get zones information
95138  * @bdev:	Target block device
96139  * @sector:	Sector from which to report zones
97
- * @zones:	Array of zone structures where to return the zones information
98
- * @nr_zones:	Number of zone structures in the zone array
99
- * @gfp_mask:	Memory allocation flags (for bio_alloc)
140
+ * @nr_zones:	Maximum number of zones to report
141
+ * @cb:		Callback function called for each reported zone
142
+ * @data:	Private data for the callback
100143  *
101144  * Description:
102
- *    Get zone information starting from the zone containing @sector.
103
- *    The number of zone information reported may be less than the number
104
- *    requested by @nr_zones. The number of zones actually reported is
105
- *    returned in @nr_zones.
145
+ *    Get zone information starting from the zone containing @sector for at most
146
+ *    @nr_zones, and call @cb for each zone reported by the device.
147
+ *    To report all zones in a device starting from @sector, the BLK_ALL_ZONES
148
+ *    constant can be passed to @nr_zones.
149
+ *    Returns the number of zones reported by the device, or a negative errno
150
+ *    value in case of failure.
151
+ *
152
+ *    Note: The caller must use memalloc_noXX_save/restore() calls to control
153
+ *    memory allocations done within this function.
106154  */
107
-int blkdev_report_zones(struct block_device *bdev,
108
-			sector_t sector,
109
-			struct blk_zone *zones,
110
-			unsigned int *nr_zones,
111
-			gfp_t gfp_mask)
155
+int blkdev_report_zones(struct block_device *bdev, sector_t sector,
156
+			unsigned int nr_zones, report_zones_cb cb, void *data)
112157 {
113
-	struct request_queue *q = bdev_get_queue(bdev);
114
-	struct blk_zone_report_hdr *hdr;
115
-	unsigned int nrz = *nr_zones;
116
-	struct page *page;
117
-	unsigned int nr_rep;
118
-	size_t rep_bytes;
119
-	unsigned int nr_pages;
120
-	struct bio *bio;
121
-	struct bio_vec *bv;
122
-	unsigned int i, n, nz;
123
-	unsigned int ofst;
124
-	void *addr;
125
-	int ret;
158
+	struct gendisk *disk = bdev->bd_disk;
159
+	sector_t capacity = get_capacity(disk);
126160 
127
-	if (!q)
128
-		return -ENXIO;
129
-
130
-	if (!blk_queue_is_zoned(q))
161
+	if (!blk_queue_is_zoned(bdev_get_queue(bdev)) ||
162
+	    WARN_ON_ONCE(!disk->fops->report_zones))
131163 		return -EOPNOTSUPP;
132164 
133
-	if (!nrz)
165
+	if (!nr_zones || sector >= capacity)
134166 		return 0;
135167 
136
-	if (sector > bdev->bd_part->nr_sects) {
137
-		*nr_zones = 0;
138
-		return 0;
139
-	}
140
-
141
-	/*
142
-	 * The zone report has a header. So make room for it in the
143
-	 * payload. Also make sure that the report fits in a single BIO
144
-	 * that will not be split down the stack.
145
-	 */
146
-	rep_bytes = sizeof(struct blk_zone_report_hdr) +
147
-		sizeof(struct blk_zone) * nrz;
148
-	rep_bytes = (rep_bytes + PAGE_SIZE - 1) & PAGE_MASK;
149
-	if (rep_bytes > (queue_max_sectors(q) << 9))
150
-		rep_bytes = queue_max_sectors(q) << 9;
151
-
152
-	nr_pages = min_t(unsigned int, BIO_MAX_PAGES,
153
-			 rep_bytes >> PAGE_SHIFT);
154
-	nr_pages = min_t(unsigned int, nr_pages,
155
-			 queue_max_segments(q));
156
-
157
-	bio = bio_alloc(gfp_mask, nr_pages);
158
-	if (!bio)
159
-		return -ENOMEM;
160
-
161
-	bio_set_dev(bio, bdev);
162
-	bio->bi_iter.bi_sector = blk_zone_start(q, sector);
163
-	bio_set_op_attrs(bio, REQ_OP_ZONE_REPORT, 0);
164
-
165
-	for (i = 0; i < nr_pages; i++) {
166
-		page = alloc_page(gfp_mask);
167
-		if (!page) {
168
-			ret = -ENOMEM;
169
-			goto out;
170
-		}
171
-		if (!bio_add_page(bio, page, PAGE_SIZE, 0)) {
172
-			__free_page(page);
173
-			break;
174
-		}
175
-	}
176
-
177
-	if (i == 0)
178
-		ret = -ENOMEM;
179
-	else
180
-		ret = submit_bio_wait(bio);
181
-	if (ret)
182
-		goto out;
183
-
184
-	/*
185
-	 * Process the report result: skip the header and go through the
186
-	 * reported zones to fixup and fixup the zone information for
187
-	 * partitions. At the same time, return the zone information into
188
-	 * the zone array.
189
-	 */
190
-	n = 0;
191
-	nz = 0;
192
-	nr_rep = 0;
193
-	bio_for_each_segment_all(bv, bio, i) {
194
-
195
-		if (!bv->bv_page)
196
-			break;
197
-
198
-		addr = kmap_atomic(bv->bv_page);
199
-
200
-		/* Get header in the first page */
201
-		ofst = 0;
202
-		if (!nr_rep) {
203
-			hdr = addr;
204
-			nr_rep = hdr->nr_zones;
205
-			ofst = sizeof(struct blk_zone_report_hdr);
206
-		}
207
-
208
-		/* Fixup and report zones */
209
-		while (ofst < bv->bv_len &&
210
-		       n < nr_rep && nz < nrz) {
211
-			if (blkdev_report_zone(bdev, addr + ofst, &zones[nz]))
212
-				nz++;
213
-			ofst += sizeof(struct blk_zone);
214
-			n++;
215
-		}
216
-
217
-		kunmap_atomic(addr);
218
-
219
-		if (n >= nr_rep || nz >= nrz)
220
-			break;
221
-
222
-	}
223
-
224
-	*nr_zones = nz;
225
-out:
226
-	bio_for_each_segment_all(bv, bio, i)
227
-		__free_page(bv->bv_page);
228
-	bio_put(bio);
229
-
230
-	return ret;
168
+	return disk->fops->report_zones(disk, sector, nr_zones, cb, data);
231169 }
232170 EXPORT_SYMBOL_GPL(blkdev_report_zones);
233171 
172
+static inline bool blkdev_allow_reset_all_zones(struct block_device *bdev,
173
+						sector_t sector,
174
+						sector_t nr_sectors)
175
+{
176
+	if (!blk_queue_zone_resetall(bdev_get_queue(bdev)))
177
+		return false;
178
+
179
+	/*
180
+	 * REQ_OP_ZONE_RESET_ALL can be executed only if the number of sectors
181
+	 * of the applicable zone range is the entire disk.
182
+	 */
183
+	return !sector && nr_sectors == get_capacity(bdev->bd_disk);
184
+}
185
+
234186 /**
235
- * blkdev_reset_zones - Reset zones write pointer
187
+ * blkdev_zone_mgmt - Execute a zone management operation on a range of zones
236188  * @bdev:	Target block device
237
- * @sector:	Start sector of the first zone to reset
238
- * @nr_sectors:	Number of sectors, at least the length of one zone
189
+ * @op:		Operation to be performed on the zones
190
+ * @sector:	Start sector of the first zone to operate on
191
+ * @nr_sectors:	Number of sectors, should be at least the length of one zone and
192
+ *		must be zone size aligned.
239193  * @gfp_mask:	Memory allocation flags (for bio_alloc)
240194  *
241195  * Description:
242
- *    Reset the write pointer of the zones contained in the range
196
+ *    Perform the specified operation on the range of zones specified by
243197  *    @sector..@sector+@nr_sectors. Specifying the entire disk sector range
244198  *    is valid, but the specified range should not contain conventional zones.
199
+ *    The operation to execute on each zone can be a zone reset, open, close
200
+ *    or finish request.
245201  */
246
-int blkdev_reset_zones(struct block_device *bdev,
247
-		       sector_t sector, sector_t nr_sectors,
248
-		       gfp_t gfp_mask)
202
+int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
203
+		     sector_t sector, sector_t nr_sectors,
204
+		     gfp_t gfp_mask)
249205 {
250206 	struct request_queue *q = bdev_get_queue(bdev);
251
-	sector_t zone_sectors;
207
+	sector_t zone_sectors = blk_queue_zone_sectors(q);
208
+	sector_t capacity = get_capacity(bdev->bd_disk);
252209 	sector_t end_sector = sector + nr_sectors;
253
-	struct bio *bio;
210
+	struct bio *bio = NULL;
254211 	int ret;
255
-
256
-	if (!q)
257
-		return -ENXIO;
258212 
259213 	if (!blk_queue_is_zoned(q))
260214 		return -EOPNOTSUPP;
261215 
262
-	if (end_sector > bdev->bd_part->nr_sects)
216
+	if (bdev_read_only(bdev))
217
+		return -EPERM;
218
+
219
+	if (!op_is_zone_mgmt(op))
220
+		return -EOPNOTSUPP;
221
+
222
+	if (end_sector <= sector || end_sector > capacity)
263223 		/* Out of range */
264224 		return -EINVAL;
265225 
266226 	/* Check alignment (handle eventual smaller last zone) */
267
-	zone_sectors = blk_queue_zone_sectors(q);
268227 	if (sector & (zone_sectors - 1))
269228 		return -EINVAL;
270229 
271
-	if ((nr_sectors & (zone_sectors - 1)) &&
272
-	    end_sector != bdev->bd_part->nr_sects)
230
+	if ((nr_sectors & (zone_sectors - 1)) && end_sector != capacity)
273231 		return -EINVAL;
274232 
275233 	while (sector < end_sector) {
276
-
277
-		bio = bio_alloc(gfp_mask, 0);
278
-		bio->bi_iter.bi_sector = sector;
234
+		bio = blk_next_bio(bio, 0, gfp_mask);
279235 		bio_set_dev(bio, bdev);
280
-		bio_set_op_attrs(bio, REQ_OP_ZONE_RESET, 0);
281236 
282
-		ret = submit_bio_wait(bio);
283
-		bio_put(bio);
237
+		/*
238
+		 * Special case for the zone reset operation that reset all
239
+		 * zones, this is useful for applications like mkfs.
240
+		 */
241
+		if (op == REQ_OP_ZONE_RESET &&
242
+		    blkdev_allow_reset_all_zones(bdev, sector, nr_sectors)) {
243
+			bio->bi_opf = REQ_OP_ZONE_RESET_ALL | REQ_SYNC;
244
+			break;
245
+		}
284246 
285
-		if (ret)
286
-			return ret;
287
-
247
+		bio->bi_opf = op | REQ_SYNC;
248
+		bio->bi_iter.bi_sector = sector;
288249 		sector += zone_sectors;
289250 
290251 		/* This may take a while, so be nice to others */
291252 		cond_resched();
292
-
293253 	}
294254 
255
+	ret = submit_bio_wait(bio);
256
+	bio_put(bio);
257
+
258
+	return ret;
259
+}
260
+EXPORT_SYMBOL_GPL(blkdev_zone_mgmt);
261
+
262
+struct zone_report_args {
263
+	struct blk_zone __user *zones;
264
+};
265
+
266
+static int blkdev_copy_zone_to_user(struct blk_zone *zone, unsigned int idx,
267
+				    void *data)
268
+{
269
+	struct zone_report_args *args = data;
270
+
271
+	if (copy_to_user(&args->zones[idx], zone, sizeof(struct blk_zone)))
272
+		return -EFAULT;
295273 	return 0;
296274 }
297
-EXPORT_SYMBOL_GPL(blkdev_reset_zones);
298275 
299276 /*
300277  * BLKREPORTZONE ioctl processing.
....@@ -304,9 +281,9 @@
304281 			      unsigned int cmd, unsigned long arg)
305282 {
306283 	void __user *argp = (void __user *)arg;
284
+	struct zone_report_args args;
307285 	struct request_queue *q;
308286 	struct blk_zone_report rep;
309
-	struct blk_zone *zones;
310287 	int ret;
311288 
312289 	if (!argp)
....@@ -325,47 +302,47 @@
325302 	if (!rep.nr_zones)
326303 		return -EINVAL;
327304 
328
-	if (rep.nr_zones > INT_MAX / sizeof(struct blk_zone))
329
-		return -ERANGE;
305
+	args.zones = argp + sizeof(struct blk_zone_report);
306
+	ret = blkdev_report_zones(bdev, rep.sector, rep.nr_zones,
307
+				  blkdev_copy_zone_to_user, &args);
308
+	if (ret < 0)
309
+		return ret;
330310 
331
-	zones = kvmalloc_array(rep.nr_zones, sizeof(struct blk_zone),
332
-			       GFP_KERNEL | __GFP_ZERO);
333
-	if (!zones)
334
-		return -ENOMEM;
311
+	rep.nr_zones = ret;
312
+	rep.flags = BLK_ZONE_REP_CAPACITY;
313
+	if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report)))
314
+		return -EFAULT;
315
+	return 0;
316
+}
335317 
336
-	ret = blkdev_report_zones(bdev, rep.sector,
337
-				  zones, &rep.nr_zones,
338
-				  GFP_KERNEL);
339
-	if (ret)
340
-		goto out;
318
+static int blkdev_truncate_zone_range(struct block_device *bdev, fmode_t mode,
319
+				      const struct blk_zone_range *zrange)
320
+{
321
+	loff_t start, end;
341322 
342
-	if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report))) {
343
-		ret = -EFAULT;
344
-		goto out;
345
-	}
323
+	if (zrange->sector + zrange->nr_sectors <= zrange->sector ||
324
+	    zrange->sector + zrange->nr_sectors > get_capacity(bdev->bd_disk))
325
+		/* Out of range */
326
+		return -EINVAL;
346327 
347
-	if (rep.nr_zones) {
348
-		if (copy_to_user(argp + sizeof(struct blk_zone_report), zones,
349
-				 sizeof(struct blk_zone) * rep.nr_zones))
350
-			ret = -EFAULT;
351
-	}
328
+	start = zrange->sector << SECTOR_SHIFT;
329
+	end = ((zrange->sector + zrange->nr_sectors) << SECTOR_SHIFT) - 1;
352330 
353
- out:
354
-	kvfree(zones);
355
-
356
-	return ret;
331
+	return truncate_bdev_range(bdev, mode, start, end);
357332 }
358333 
359334 /*
360
- * BLKRESETZONE ioctl processing.
335
+ * BLKRESETZONE, BLKOPENZONE, BLKCLOSEZONE and BLKFINISHZONE ioctl processing.
361336  * Called from blkdev_ioctl.
362337  */
363
-int blkdev_reset_zones_ioctl(struct block_device *bdev, fmode_t mode,
364
-			     unsigned int cmd, unsigned long arg)
338
+int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode,
339
+			   unsigned int cmd, unsigned long arg)
365340 {
366341 	void __user *argp = (void __user *)arg;
367342 	struct request_queue *q;
368343 	struct blk_zone_range zrange;
344
+	enum req_opf op;
345
+	int ret;
369346 
370347 	if (!argp)
371348 		return -EINVAL;
....@@ -383,6 +360,206 @@
383360 	if (copy_from_user(&zrange, argp, sizeof(struct blk_zone_range)))
384361 		return -EFAULT;
385362 
386
-	return blkdev_reset_zones(bdev, zrange.sector, zrange.nr_sectors,
387
-				  GFP_KERNEL);
363
+	switch (cmd) {
364
+	case BLKRESETZONE:
365
+		op = REQ_OP_ZONE_RESET;
366
+
367
+		/* Invalidate the page cache, including dirty pages. */
368
+		ret = blkdev_truncate_zone_range(bdev, mode, &zrange);
369
+		if (ret)
370
+			return ret;
371
+		break;
372
+	case BLKOPENZONE:
373
+		op = REQ_OP_ZONE_OPEN;
374
+		break;
375
+	case BLKCLOSEZONE:
376
+		op = REQ_OP_ZONE_CLOSE;
377
+		break;
378
+	case BLKFINISHZONE:
379
+		op = REQ_OP_ZONE_FINISH;
380
+		break;
381
+	default:
382
+		return -ENOTTY;
383
+	}
384
+
385
+	ret = blkdev_zone_mgmt(bdev, op, zrange.sector, zrange.nr_sectors,
386
+			       GFP_KERNEL);
387
+
388
+	/*
389
+	 * Invalidate the page cache again for zone reset: writes can only be
390
+	 * direct for zoned devices so concurrent writes would not add any page
391
+	 * to the page cache after/during reset. The page cache may be filled
392
+	 * again due to concurrent reads though and dropping the pages for
393
+	 * these is fine.
394
+	 */
395
+	if (!ret && cmd == BLKRESETZONE)
396
+		ret = blkdev_truncate_zone_range(bdev, mode, &zrange);
397
+
398
+	return ret;
388399 }
400
+
401
+static inline unsigned long *blk_alloc_zone_bitmap(int node,
402
+						   unsigned int nr_zones)
403
+{
404
+	return kcalloc_node(BITS_TO_LONGS(nr_zones), sizeof(unsigned long),
405
+			    GFP_NOIO, node);
406
+}
407
+
408
+void blk_queue_free_zone_bitmaps(struct request_queue *q)
409
+{
410
+	kfree(q->conv_zones_bitmap);
411
+	q->conv_zones_bitmap = NULL;
412
+	kfree(q->seq_zones_wlock);
413
+	q->seq_zones_wlock = NULL;
414
+}
415
+
416
+struct blk_revalidate_zone_args {
417
+	struct gendisk	*disk;
418
+	unsigned long	*conv_zones_bitmap;
419
+	unsigned long	*seq_zones_wlock;
420
+	unsigned int	nr_zones;
421
+	sector_t	zone_sectors;
422
+	sector_t	sector;
423
+};
424
+
425
+/*
426
+ * Helper function to check the validity of zones of a zoned block device.
427
+ */
428
+static int blk_revalidate_zone_cb(struct blk_zone *zone, unsigned int idx,
429
+				  void *data)
430
+{
431
+	struct blk_revalidate_zone_args *args = data;
432
+	struct gendisk *disk = args->disk;
433
+	struct request_queue *q = disk->queue;
434
+	sector_t capacity = get_capacity(disk);
435
+
436
+	/*
437
+	 * All zones must have the same size, with the exception on an eventual
438
+	 * smaller last zone.
439
+	 */
440
+	if (zone->start == 0) {
441
+		if (zone->len == 0 || !is_power_of_2(zone->len)) {
442
+			pr_warn("%s: Invalid zoned device with non power of two zone size (%llu)\n",
443
+				disk->disk_name, zone->len);
444
+			return -ENODEV;
445
+		}
446
+
447
+		args->zone_sectors = zone->len;
448
+		args->nr_zones = (capacity + zone->len - 1) >> ilog2(zone->len);
449
+	} else if (zone->start + args->zone_sectors < capacity) {
450
+		if (zone->len != args->zone_sectors) {
451
+			pr_warn("%s: Invalid zoned device with non constant zone size\n",
452
+				disk->disk_name);
453
+			return -ENODEV;
454
+		}
455
+	} else {
456
+		if (zone->len > args->zone_sectors) {
457
+			pr_warn("%s: Invalid zoned device with larger last zone size\n",
458
+				disk->disk_name);
459
+			return -ENODEV;
460
+		}
461
+	}
462
+
463
+	/* Check for holes in the zone report */
464
+	if (zone->start != args->sector) {
465
+		pr_warn("%s: Zone gap at sectors %llu..%llu\n",
466
+			disk->disk_name, args->sector, zone->start);
467
+		return -ENODEV;
468
+	}
469
+
470
+	/* Check zone type */
471
+	switch (zone->type) {
472
+	case BLK_ZONE_TYPE_CONVENTIONAL:
473
+		if (!args->conv_zones_bitmap) {
474
+			args->conv_zones_bitmap =
475
+				blk_alloc_zone_bitmap(q->node, args->nr_zones);
476
+			if (!args->conv_zones_bitmap)
477
+				return -ENOMEM;
478
+		}
479
+		set_bit(idx, args->conv_zones_bitmap);
480
+		break;
481
+	case BLK_ZONE_TYPE_SEQWRITE_REQ:
482
+	case BLK_ZONE_TYPE_SEQWRITE_PREF:
483
+		if (!args->seq_zones_wlock) {
484
+			args->seq_zones_wlock =
485
+				blk_alloc_zone_bitmap(q->node, args->nr_zones);
486
+			if (!args->seq_zones_wlock)
487
+				return -ENOMEM;
488
+		}
489
+		break;
490
+	default:
491
+		pr_warn("%s: Invalid zone type 0x%x at sectors %llu\n",
492
+			disk->disk_name, (int)zone->type, zone->start);
493
+		return -ENODEV;
494
+	}
495
+
496
+	args->sector += zone->len;
497
+	return 0;
498
+}
499
+
500
+/**
501
+ * blk_revalidate_disk_zones - (re)allocate and initialize zone bitmaps
502
+ * @disk:	Target disk
503
+ * @update_driver_data:	Callback to update driver data on the frozen disk
504
+ *
505
+ * Helper function for low-level device drivers to (re) allocate and initialize
506
+ * a disk request queue zone bitmaps. This functions should normally be called
507
+ * within the disk ->revalidate method for blk-mq based drivers.  For BIO based
508
+ * drivers only q->nr_zones needs to be updated so that the sysfs exposed value
509
+ * is correct.
510
+ * If the @update_driver_data callback function is not NULL, the callback is
511
+ * executed with the device request queue frozen after all zones have been
512
+ * checked.
513
+ */
514
+int blk_revalidate_disk_zones(struct gendisk *disk,
515
+			      void (*update_driver_data)(struct gendisk *disk))
516
+{
517
+	struct request_queue *q = disk->queue;
518
+	struct blk_revalidate_zone_args args = {
519
+		.disk		= disk,
520
+	};
521
+	unsigned int noio_flag;
522
+	int ret;
523
+
524
+	if (WARN_ON_ONCE(!blk_queue_is_zoned(q)))
525
+		return -EIO;
526
+	if (WARN_ON_ONCE(!queue_is_mq(q)))
527
+		return -EIO;
528
+
529
+	if (!get_capacity(disk))
530
+		return -EIO;
531
+
532
+	/*
533
+	 * Ensure that all memory allocations in this context are done as if
534
+	 * GFP_NOIO was specified.
535
+	 */
536
+	noio_flag = memalloc_noio_save();
537
+	ret = disk->fops->report_zones(disk, 0, UINT_MAX,
538
+				       blk_revalidate_zone_cb, &args);
539
+	memalloc_noio_restore(noio_flag);
540
+
541
+	/*
542
+	 * Install the new bitmaps and update nr_zones only once the queue is
543
+	 * stopped and all I/Os are completed (i.e. a scheduler is not
544
+	 * referencing the bitmaps).
545
+	 */
546
+	blk_mq_freeze_queue(q);
547
+	if (ret >= 0) {
548
+		blk_queue_chunk_sectors(q, args.zone_sectors);
549
+		q->nr_zones = args.nr_zones;
550
+		swap(q->seq_zones_wlock, args.seq_zones_wlock);
551
+		swap(q->conv_zones_bitmap, args.conv_zones_bitmap);
552
+		if (update_driver_data)
553
+			update_driver_data(disk);
554
+		ret = 0;
555
+	} else {
556
+		pr_warn("%s: failed to revalidate zones\n", disk->disk_name);
557
+		blk_queue_free_zone_bitmaps(q);
558
+	}
559
+	blk_mq_unfreeze_queue(q);
560
+
561
+	kfree(args.seq_zones_wlock);
562
+	kfree(args.conv_zones_bitmap);
563
+	return ret;
564
+}
565
+EXPORT_SYMBOL_GPL(blk_revalidate_disk_zones);