xref: /linux/fs/btrfs/zoned.c (revision 031fba65fc202abf1f193e321be7a2c274fd88ba)
1 // SPDX-License-Identifier: GPL-2.0
2 
3 #include <linux/bitops.h>
4 #include <linux/slab.h>
5 #include <linux/blkdev.h>
6 #include <linux/sched/mm.h>
7 #include <linux/atomic.h>
8 #include <linux/vmalloc.h>
9 #include "ctree.h"
10 #include "volumes.h"
11 #include "zoned.h"
12 #include "rcu-string.h"
13 #include "disk-io.h"
14 #include "block-group.h"
15 #include "transaction.h"
16 #include "dev-replace.h"
17 #include "space-info.h"
18 #include "super.h"
19 #include "fs.h"
20 #include "accessors.h"
21 #include "bio.h"
22 
23 /* Maximum number of zones to report per blkdev_report_zones() call */
24 #define BTRFS_REPORT_NR_ZONES   4096
25 /* Invalid allocation pointer value for missing devices */
26 #define WP_MISSING_DEV ((u64)-1)
27 /* Pseudo write pointer value for conventional zone */
28 #define WP_CONVENTIONAL ((u64)-2)
29 
30 /*
31  * Location of the first zone of superblock logging zone pairs.
32  *
33  * - primary superblock:    0B (zone 0)
34  * - first copy:          512G (zone starting at that offset)
35  * - second copy:           4T (zone starting at that offset)
36  */
37 #define BTRFS_SB_LOG_PRIMARY_OFFSET	(0ULL)
38 #define BTRFS_SB_LOG_FIRST_OFFSET	(512ULL * SZ_1G)
39 #define BTRFS_SB_LOG_SECOND_OFFSET	(4096ULL * SZ_1G)
40 
41 #define BTRFS_SB_LOG_FIRST_SHIFT	const_ilog2(BTRFS_SB_LOG_FIRST_OFFSET)
42 #define BTRFS_SB_LOG_SECOND_SHIFT	const_ilog2(BTRFS_SB_LOG_SECOND_OFFSET)
43 
44 /* Number of superblock log zones */
45 #define BTRFS_NR_SB_LOG_ZONES 2
46 
47 /*
48  * Minimum of active zones we need:
49  *
50  * - BTRFS_SUPER_MIRROR_MAX zones for superblock mirrors
51  * - 3 zones to ensure at least one zone per SYSTEM, META and DATA block group
52  * - 1 zone for tree-log dedicated block group
53  * - 1 zone for relocation
54  */
55 #define BTRFS_MIN_ACTIVE_ZONES		(BTRFS_SUPER_MIRROR_MAX + 5)
56 
57 /*
58  * Minimum / maximum supported zone size. Currently, SMR disks have a zone
59  * size of 256MiB, and we are expecting ZNS drives to be in the 1-4GiB range.
60  * We do not expect the zone size to become larger than 8GiB or smaller than
61  * 4MiB in the near future.
62  */
63 #define BTRFS_MAX_ZONE_SIZE		SZ_8G
64 #define BTRFS_MIN_ZONE_SIZE		SZ_4M
65 
66 #define SUPER_INFO_SECTORS	((u64)BTRFS_SUPER_INFO_SIZE >> SECTOR_SHIFT)
67 
68 static void wait_eb_writebacks(struct btrfs_block_group *block_group);
69 static int do_zone_finish(struct btrfs_block_group *block_group, bool fully_written);
70 
71 static inline bool sb_zone_is_full(const struct blk_zone *zone)
72 {
73 	return (zone->cond == BLK_ZONE_COND_FULL) ||
74 		(zone->wp + SUPER_INFO_SECTORS > zone->start + zone->capacity);
75 }
76 
77 static int copy_zone_info_cb(struct blk_zone *zone, unsigned int idx, void *data)
78 {
79 	struct blk_zone *zones = data;
80 
81 	memcpy(&zones[idx], zone, sizeof(*zone));
82 
83 	return 0;
84 }
85 
86 static int sb_write_pointer(struct block_device *bdev, struct blk_zone *zones,
87 			    u64 *wp_ret)
88 {
89 	bool empty[BTRFS_NR_SB_LOG_ZONES];
90 	bool full[BTRFS_NR_SB_LOG_ZONES];
91 	sector_t sector;
92 	int i;
93 
94 	for (i = 0; i < BTRFS_NR_SB_LOG_ZONES; i++) {
95 		ASSERT(zones[i].type != BLK_ZONE_TYPE_CONVENTIONAL);
96 		empty[i] = (zones[i].cond == BLK_ZONE_COND_EMPTY);
97 		full[i] = sb_zone_is_full(&zones[i]);
98 	}
99 
100 	/*
101 	 * Possible states of log buffer zones
102 	 *
103 	 *           Empty[0]  In use[0]  Full[0]
104 	 * Empty[1]         *          0        1
105 	 * In use[1]        x          x        1
106 	 * Full[1]          0          0        C
107 	 *
108 	 * Log position:
109 	 *   *: Special case, no superblock is written
110 	 *   0: Use write pointer of zones[0]
111 	 *   1: Use write pointer of zones[1]
112 	 *   C: Compare super blocks from zones[0] and zones[1], use the latest
113 	 *      one determined by generation
114 	 *   x: Invalid state
115 	 */
116 
117 	if (empty[0] && empty[1]) {
118 		/* Special case to distinguish no superblock to read */
119 		*wp_ret = zones[0].start << SECTOR_SHIFT;
120 		return -ENOENT;
121 	} else if (full[0] && full[1]) {
122 		/* Compare two super blocks */
123 		struct address_space *mapping = bdev->bd_inode->i_mapping;
124 		struct page *page[BTRFS_NR_SB_LOG_ZONES];
125 		struct btrfs_super_block *super[BTRFS_NR_SB_LOG_ZONES];
126 		int i;
127 
128 		for (i = 0; i < BTRFS_NR_SB_LOG_ZONES; i++) {
129 			u64 zone_end = (zones[i].start + zones[i].capacity) << SECTOR_SHIFT;
130 			u64 bytenr = ALIGN_DOWN(zone_end, BTRFS_SUPER_INFO_SIZE) -
131 						BTRFS_SUPER_INFO_SIZE;
132 
133 			page[i] = read_cache_page_gfp(mapping,
134 					bytenr >> PAGE_SHIFT, GFP_NOFS);
135 			if (IS_ERR(page[i])) {
136 				if (i == 1)
137 					btrfs_release_disk_super(super[0]);
138 				return PTR_ERR(page[i]);
139 			}
140 			super[i] = page_address(page[i]);
141 		}
142 
143 		if (btrfs_super_generation(super[0]) >
144 		    btrfs_super_generation(super[1]))
145 			sector = zones[1].start;
146 		else
147 			sector = zones[0].start;
148 
149 		for (i = 0; i < BTRFS_NR_SB_LOG_ZONES; i++)
150 			btrfs_release_disk_super(super[i]);
151 	} else if (!full[0] && (empty[1] || full[1])) {
152 		sector = zones[0].wp;
153 	} else if (full[0]) {
154 		sector = zones[1].wp;
155 	} else {
156 		return -EUCLEAN;
157 	}
158 	*wp_ret = sector << SECTOR_SHIFT;
159 	return 0;
160 }
161 
162 /*
163  * Get the first zone number of the superblock mirror
164  */
165 static inline u32 sb_zone_number(int shift, int mirror)
166 {
167 	u64 zone = U64_MAX;
168 
169 	ASSERT(mirror < BTRFS_SUPER_MIRROR_MAX);
170 	switch (mirror) {
171 	case 0: zone = 0; break;
172 	case 1: zone = 1ULL << (BTRFS_SB_LOG_FIRST_SHIFT - shift); break;
173 	case 2: zone = 1ULL << (BTRFS_SB_LOG_SECOND_SHIFT - shift); break;
174 	}
175 
176 	ASSERT(zone <= U32_MAX);
177 
178 	return (u32)zone;
179 }
180 
181 static inline sector_t zone_start_sector(u32 zone_number,
182 					 struct block_device *bdev)
183 {
184 	return (sector_t)zone_number << ilog2(bdev_zone_sectors(bdev));
185 }
186 
187 static inline u64 zone_start_physical(u32 zone_number,
188 				      struct btrfs_zoned_device_info *zone_info)
189 {
190 	return (u64)zone_number << zone_info->zone_size_shift;
191 }
192 
193 /*
194  * Emulate blkdev_report_zones() for a non-zoned device. It slices up the block
195  * device into static sized chunks and fake a conventional zone on each of
196  * them.
197  */
198 static int emulate_report_zones(struct btrfs_device *device, u64 pos,
199 				struct blk_zone *zones, unsigned int nr_zones)
200 {
201 	const sector_t zone_sectors = device->fs_info->zone_size >> SECTOR_SHIFT;
202 	sector_t bdev_size = bdev_nr_sectors(device->bdev);
203 	unsigned int i;
204 
205 	pos >>= SECTOR_SHIFT;
206 	for (i = 0; i < nr_zones; i++) {
207 		zones[i].start = i * zone_sectors + pos;
208 		zones[i].len = zone_sectors;
209 		zones[i].capacity = zone_sectors;
210 		zones[i].wp = zones[i].start + zone_sectors;
211 		zones[i].type = BLK_ZONE_TYPE_CONVENTIONAL;
212 		zones[i].cond = BLK_ZONE_COND_NOT_WP;
213 
214 		if (zones[i].wp >= bdev_size) {
215 			i++;
216 			break;
217 		}
218 	}
219 
220 	return i;
221 }
222 
223 static int btrfs_get_dev_zones(struct btrfs_device *device, u64 pos,
224 			       struct blk_zone *zones, unsigned int *nr_zones)
225 {
226 	struct btrfs_zoned_device_info *zinfo = device->zone_info;
227 	int ret;
228 
229 	if (!*nr_zones)
230 		return 0;
231 
232 	if (!bdev_is_zoned(device->bdev)) {
233 		ret = emulate_report_zones(device, pos, zones, *nr_zones);
234 		*nr_zones = ret;
235 		return 0;
236 	}
237 
238 	/* Check cache */
239 	if (zinfo->zone_cache) {
240 		unsigned int i;
241 		u32 zno;
242 
243 		ASSERT(IS_ALIGNED(pos, zinfo->zone_size));
244 		zno = pos >> zinfo->zone_size_shift;
245 		/*
246 		 * We cannot report zones beyond the zone end. So, it is OK to
247 		 * cap *nr_zones to at the end.
248 		 */
249 		*nr_zones = min_t(u32, *nr_zones, zinfo->nr_zones - zno);
250 
251 		for (i = 0; i < *nr_zones; i++) {
252 			struct blk_zone *zone_info;
253 
254 			zone_info = &zinfo->zone_cache[zno + i];
255 			if (!zone_info->len)
256 				break;
257 		}
258 
259 		if (i == *nr_zones) {
260 			/* Cache hit on all the zones */
261 			memcpy(zones, zinfo->zone_cache + zno,
262 			       sizeof(*zinfo->zone_cache) * *nr_zones);
263 			return 0;
264 		}
265 	}
266 
267 	ret = blkdev_report_zones(device->bdev, pos >> SECTOR_SHIFT, *nr_zones,
268 				  copy_zone_info_cb, zones);
269 	if (ret < 0) {
270 		btrfs_err_in_rcu(device->fs_info,
271 				 "zoned: failed to read zone %llu on %s (devid %llu)",
272 				 pos, rcu_str_deref(device->name),
273 				 device->devid);
274 		return ret;
275 	}
276 	*nr_zones = ret;
277 	if (!ret)
278 		return -EIO;
279 
280 	/* Populate cache */
281 	if (zinfo->zone_cache) {
282 		u32 zno = pos >> zinfo->zone_size_shift;
283 
284 		memcpy(zinfo->zone_cache + zno, zones,
285 		       sizeof(*zinfo->zone_cache) * *nr_zones);
286 	}
287 
288 	return 0;
289 }
290 
291 /* The emulated zone size is determined from the size of device extent */
292 static int calculate_emulated_zone_size(struct btrfs_fs_info *fs_info)
293 {
294 	struct btrfs_path *path;
295 	struct btrfs_root *root = fs_info->dev_root;
296 	struct btrfs_key key;
297 	struct extent_buffer *leaf;
298 	struct btrfs_dev_extent *dext;
299 	int ret = 0;
300 
301 	key.objectid = 1;
302 	key.type = BTRFS_DEV_EXTENT_KEY;
303 	key.offset = 0;
304 
305 	path = btrfs_alloc_path();
306 	if (!path)
307 		return -ENOMEM;
308 
309 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
310 	if (ret < 0)
311 		goto out;
312 
313 	if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
314 		ret = btrfs_next_leaf(root, path);
315 		if (ret < 0)
316 			goto out;
317 		/* No dev extents at all? Not good */
318 		if (ret > 0) {
319 			ret = -EUCLEAN;
320 			goto out;
321 		}
322 	}
323 
324 	leaf = path->nodes[0];
325 	dext = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dev_extent);
326 	fs_info->zone_size = btrfs_dev_extent_length(leaf, dext);
327 	ret = 0;
328 
329 out:
330 	btrfs_free_path(path);
331 
332 	return ret;
333 }
334 
335 int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info)
336 {
337 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
338 	struct btrfs_device *device;
339 	int ret = 0;
340 
341 	/* fs_info->zone_size might not set yet. Use the incomapt flag here. */
342 	if (!btrfs_fs_incompat(fs_info, ZONED))
343 		return 0;
344 
345 	mutex_lock(&fs_devices->device_list_mutex);
346 	list_for_each_entry(device, &fs_devices->devices, dev_list) {
347 		/* We can skip reading of zone info for missing devices */
348 		if (!device->bdev)
349 			continue;
350 
351 		ret = btrfs_get_dev_zone_info(device, true);
352 		if (ret)
353 			break;
354 	}
355 	mutex_unlock(&fs_devices->device_list_mutex);
356 
357 	return ret;
358 }
359 
360 int btrfs_get_dev_zone_info(struct btrfs_device *device, bool populate_cache)
361 {
362 	struct btrfs_fs_info *fs_info = device->fs_info;
363 	struct btrfs_zoned_device_info *zone_info = NULL;
364 	struct block_device *bdev = device->bdev;
365 	unsigned int max_active_zones;
366 	unsigned int nactive;
367 	sector_t nr_sectors;
368 	sector_t sector = 0;
369 	struct blk_zone *zones = NULL;
370 	unsigned int i, nreported = 0, nr_zones;
371 	sector_t zone_sectors;
372 	char *model, *emulated;
373 	int ret;
374 
375 	/*
376 	 * Cannot use btrfs_is_zoned here, since fs_info::zone_size might not
377 	 * yet be set.
378 	 */
379 	if (!btrfs_fs_incompat(fs_info, ZONED))
380 		return 0;
381 
382 	if (device->zone_info)
383 		return 0;
384 
385 	zone_info = kzalloc(sizeof(*zone_info), GFP_KERNEL);
386 	if (!zone_info)
387 		return -ENOMEM;
388 
389 	device->zone_info = zone_info;
390 
391 	if (!bdev_is_zoned(bdev)) {
392 		if (!fs_info->zone_size) {
393 			ret = calculate_emulated_zone_size(fs_info);
394 			if (ret)
395 				goto out;
396 		}
397 
398 		ASSERT(fs_info->zone_size);
399 		zone_sectors = fs_info->zone_size >> SECTOR_SHIFT;
400 	} else {
401 		zone_sectors = bdev_zone_sectors(bdev);
402 	}
403 
404 	ASSERT(is_power_of_two_u64(zone_sectors));
405 	zone_info->zone_size = zone_sectors << SECTOR_SHIFT;
406 
407 	/* We reject devices with a zone size larger than 8GB */
408 	if (zone_info->zone_size > BTRFS_MAX_ZONE_SIZE) {
409 		btrfs_err_in_rcu(fs_info,
410 		"zoned: %s: zone size %llu larger than supported maximum %llu",
411 				 rcu_str_deref(device->name),
412 				 zone_info->zone_size, BTRFS_MAX_ZONE_SIZE);
413 		ret = -EINVAL;
414 		goto out;
415 	} else if (zone_info->zone_size < BTRFS_MIN_ZONE_SIZE) {
416 		btrfs_err_in_rcu(fs_info,
417 		"zoned: %s: zone size %llu smaller than supported minimum %u",
418 				 rcu_str_deref(device->name),
419 				 zone_info->zone_size, BTRFS_MIN_ZONE_SIZE);
420 		ret = -EINVAL;
421 		goto out;
422 	}
423 
424 	nr_sectors = bdev_nr_sectors(bdev);
425 	zone_info->zone_size_shift = ilog2(zone_info->zone_size);
426 	zone_info->nr_zones = nr_sectors >> ilog2(zone_sectors);
427 	if (!IS_ALIGNED(nr_sectors, zone_sectors))
428 		zone_info->nr_zones++;
429 
430 	max_active_zones = bdev_max_active_zones(bdev);
431 	if (max_active_zones && max_active_zones < BTRFS_MIN_ACTIVE_ZONES) {
432 		btrfs_err_in_rcu(fs_info,
433 "zoned: %s: max active zones %u is too small, need at least %u active zones",
434 				 rcu_str_deref(device->name), max_active_zones,
435 				 BTRFS_MIN_ACTIVE_ZONES);
436 		ret = -EINVAL;
437 		goto out;
438 	}
439 	zone_info->max_active_zones = max_active_zones;
440 
441 	zone_info->seq_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL);
442 	if (!zone_info->seq_zones) {
443 		ret = -ENOMEM;
444 		goto out;
445 	}
446 
447 	zone_info->empty_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL);
448 	if (!zone_info->empty_zones) {
449 		ret = -ENOMEM;
450 		goto out;
451 	}
452 
453 	zone_info->active_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL);
454 	if (!zone_info->active_zones) {
455 		ret = -ENOMEM;
456 		goto out;
457 	}
458 
459 	zones = kvcalloc(BTRFS_REPORT_NR_ZONES, sizeof(struct blk_zone), GFP_KERNEL);
460 	if (!zones) {
461 		ret = -ENOMEM;
462 		goto out;
463 	}
464 
465 	/*
466 	 * Enable zone cache only for a zoned device. On a non-zoned device, we
467 	 * fill the zone info with emulated CONVENTIONAL zones, so no need to
468 	 * use the cache.
469 	 */
470 	if (populate_cache && bdev_is_zoned(device->bdev)) {
471 		zone_info->zone_cache = vcalloc(zone_info->nr_zones,
472 						sizeof(struct blk_zone));
473 		if (!zone_info->zone_cache) {
474 			btrfs_err_in_rcu(device->fs_info,
475 				"zoned: failed to allocate zone cache for %s",
476 				rcu_str_deref(device->name));
477 			ret = -ENOMEM;
478 			goto out;
479 		}
480 	}
481 
482 	/* Get zones type */
483 	nactive = 0;
484 	while (sector < nr_sectors) {
485 		nr_zones = BTRFS_REPORT_NR_ZONES;
486 		ret = btrfs_get_dev_zones(device, sector << SECTOR_SHIFT, zones,
487 					  &nr_zones);
488 		if (ret)
489 			goto out;
490 
491 		for (i = 0; i < nr_zones; i++) {
492 			if (zones[i].type == BLK_ZONE_TYPE_SEQWRITE_REQ)
493 				__set_bit(nreported, zone_info->seq_zones);
494 			switch (zones[i].cond) {
495 			case BLK_ZONE_COND_EMPTY:
496 				__set_bit(nreported, zone_info->empty_zones);
497 				break;
498 			case BLK_ZONE_COND_IMP_OPEN:
499 			case BLK_ZONE_COND_EXP_OPEN:
500 			case BLK_ZONE_COND_CLOSED:
501 				__set_bit(nreported, zone_info->active_zones);
502 				nactive++;
503 				break;
504 			}
505 			nreported++;
506 		}
507 		sector = zones[nr_zones - 1].start + zones[nr_zones - 1].len;
508 	}
509 
510 	if (nreported != zone_info->nr_zones) {
511 		btrfs_err_in_rcu(device->fs_info,
512 				 "inconsistent number of zones on %s (%u/%u)",
513 				 rcu_str_deref(device->name), nreported,
514 				 zone_info->nr_zones);
515 		ret = -EIO;
516 		goto out;
517 	}
518 
519 	if (max_active_zones) {
520 		if (nactive > max_active_zones) {
521 			btrfs_err_in_rcu(device->fs_info,
522 			"zoned: %u active zones on %s exceeds max_active_zones %u",
523 					 nactive, rcu_str_deref(device->name),
524 					 max_active_zones);
525 			ret = -EIO;
526 			goto out;
527 		}
528 		atomic_set(&zone_info->active_zones_left,
529 			   max_active_zones - nactive);
530 		set_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags);
531 	}
532 
533 	/* Validate superblock log */
534 	nr_zones = BTRFS_NR_SB_LOG_ZONES;
535 	for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
536 		u32 sb_zone;
537 		u64 sb_wp;
538 		int sb_pos = BTRFS_NR_SB_LOG_ZONES * i;
539 
540 		sb_zone = sb_zone_number(zone_info->zone_size_shift, i);
541 		if (sb_zone + 1 >= zone_info->nr_zones)
542 			continue;
543 
544 		ret = btrfs_get_dev_zones(device,
545 					  zone_start_physical(sb_zone, zone_info),
546 					  &zone_info->sb_zones[sb_pos],
547 					  &nr_zones);
548 		if (ret)
549 			goto out;
550 
551 		if (nr_zones != BTRFS_NR_SB_LOG_ZONES) {
552 			btrfs_err_in_rcu(device->fs_info,
553 	"zoned: failed to read super block log zone info at devid %llu zone %u",
554 					 device->devid, sb_zone);
555 			ret = -EUCLEAN;
556 			goto out;
557 		}
558 
559 		/*
560 		 * If zones[0] is conventional, always use the beginning of the
561 		 * zone to record superblock. No need to validate in that case.
562 		 */
563 		if (zone_info->sb_zones[BTRFS_NR_SB_LOG_ZONES * i].type ==
564 		    BLK_ZONE_TYPE_CONVENTIONAL)
565 			continue;
566 
567 		ret = sb_write_pointer(device->bdev,
568 				       &zone_info->sb_zones[sb_pos], &sb_wp);
569 		if (ret != -ENOENT && ret) {
570 			btrfs_err_in_rcu(device->fs_info,
571 			"zoned: super block log zone corrupted devid %llu zone %u",
572 					 device->devid, sb_zone);
573 			ret = -EUCLEAN;
574 			goto out;
575 		}
576 	}
577 
578 
579 	kvfree(zones);
580 
581 	switch (bdev_zoned_model(bdev)) {
582 	case BLK_ZONED_HM:
583 		model = "host-managed zoned";
584 		emulated = "";
585 		break;
586 	case BLK_ZONED_HA:
587 		model = "host-aware zoned";
588 		emulated = "";
589 		break;
590 	case BLK_ZONED_NONE:
591 		model = "regular";
592 		emulated = "emulated ";
593 		break;
594 	default:
595 		/* Just in case */
596 		btrfs_err_in_rcu(fs_info, "zoned: unsupported model %d on %s",
597 				 bdev_zoned_model(bdev),
598 				 rcu_str_deref(device->name));
599 		ret = -EOPNOTSUPP;
600 		goto out_free_zone_info;
601 	}
602 
603 	btrfs_info_in_rcu(fs_info,
604 		"%s block device %s, %u %szones of %llu bytes",
605 		model, rcu_str_deref(device->name), zone_info->nr_zones,
606 		emulated, zone_info->zone_size);
607 
608 	return 0;
609 
610 out:
611 	kvfree(zones);
612 out_free_zone_info:
613 	btrfs_destroy_dev_zone_info(device);
614 
615 	return ret;
616 }
617 
618 void btrfs_destroy_dev_zone_info(struct btrfs_device *device)
619 {
620 	struct btrfs_zoned_device_info *zone_info = device->zone_info;
621 
622 	if (!zone_info)
623 		return;
624 
625 	bitmap_free(zone_info->active_zones);
626 	bitmap_free(zone_info->seq_zones);
627 	bitmap_free(zone_info->empty_zones);
628 	vfree(zone_info->zone_cache);
629 	kfree(zone_info);
630 	device->zone_info = NULL;
631 }
632 
633 struct btrfs_zoned_device_info *btrfs_clone_dev_zone_info(struct btrfs_device *orig_dev)
634 {
635 	struct btrfs_zoned_device_info *zone_info;
636 
637 	zone_info = kmemdup(orig_dev->zone_info, sizeof(*zone_info), GFP_KERNEL);
638 	if (!zone_info)
639 		return NULL;
640 
641 	zone_info->seq_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL);
642 	if (!zone_info->seq_zones)
643 		goto out;
644 
645 	bitmap_copy(zone_info->seq_zones, orig_dev->zone_info->seq_zones,
646 		    zone_info->nr_zones);
647 
648 	zone_info->empty_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL);
649 	if (!zone_info->empty_zones)
650 		goto out;
651 
652 	bitmap_copy(zone_info->empty_zones, orig_dev->zone_info->empty_zones,
653 		    zone_info->nr_zones);
654 
655 	zone_info->active_zones = bitmap_zalloc(zone_info->nr_zones, GFP_KERNEL);
656 	if (!zone_info->active_zones)
657 		goto out;
658 
659 	bitmap_copy(zone_info->active_zones, orig_dev->zone_info->active_zones,
660 		    zone_info->nr_zones);
661 	zone_info->zone_cache = NULL;
662 
663 	return zone_info;
664 
665 out:
666 	bitmap_free(zone_info->seq_zones);
667 	bitmap_free(zone_info->empty_zones);
668 	bitmap_free(zone_info->active_zones);
669 	kfree(zone_info);
670 	return NULL;
671 }
672 
673 int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos,
674 		       struct blk_zone *zone)
675 {
676 	unsigned int nr_zones = 1;
677 	int ret;
678 
679 	ret = btrfs_get_dev_zones(device, pos, zone, &nr_zones);
680 	if (ret != 0 || !nr_zones)
681 		return ret ? ret : -EIO;
682 
683 	return 0;
684 }
685 
686 static int btrfs_check_for_zoned_device(struct btrfs_fs_info *fs_info)
687 {
688 	struct btrfs_device *device;
689 
690 	list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {
691 		if (device->bdev &&
692 		    bdev_zoned_model(device->bdev) == BLK_ZONED_HM) {
693 			btrfs_err(fs_info,
694 				"zoned: mode not enabled but zoned device found: %pg",
695 				device->bdev);
696 			return -EINVAL;
697 		}
698 	}
699 
700 	return 0;
701 }
702 
703 int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info)
704 {
705 	struct queue_limits *lim = &fs_info->limits;
706 	struct btrfs_device *device;
707 	u64 zone_size = 0;
708 	int ret;
709 
710 	/*
711 	 * Host-Managed devices can't be used without the ZONED flag.  With the
712 	 * ZONED all devices can be used, using zone emulation if required.
713 	 */
714 	if (!btrfs_fs_incompat(fs_info, ZONED))
715 		return btrfs_check_for_zoned_device(fs_info);
716 
717 	blk_set_stacking_limits(lim);
718 
719 	list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {
720 		struct btrfs_zoned_device_info *zone_info = device->zone_info;
721 
722 		if (!device->bdev)
723 			continue;
724 
725 		if (!zone_size) {
726 			zone_size = zone_info->zone_size;
727 		} else if (zone_info->zone_size != zone_size) {
728 			btrfs_err(fs_info,
729 		"zoned: unequal block device zone sizes: have %llu found %llu",
730 				  zone_info->zone_size, zone_size);
731 			return -EINVAL;
732 		}
733 
734 		/*
735 		 * With the zoned emulation, we can have non-zoned device on the
736 		 * zoned mode. In this case, we don't have a valid max zone
737 		 * append size.
738 		 */
739 		if (bdev_is_zoned(device->bdev)) {
740 			blk_stack_limits(lim,
741 					 &bdev_get_queue(device->bdev)->limits,
742 					 0);
743 		}
744 	}
745 
746 	/*
747 	 * stripe_size is always aligned to BTRFS_STRIPE_LEN in
748 	 * btrfs_create_chunk(). Since we want stripe_len == zone_size,
749 	 * check the alignment here.
750 	 */
751 	if (!IS_ALIGNED(zone_size, BTRFS_STRIPE_LEN)) {
752 		btrfs_err(fs_info,
753 			  "zoned: zone size %llu not aligned to stripe %u",
754 			  zone_size, BTRFS_STRIPE_LEN);
755 		return -EINVAL;
756 	}
757 
758 	if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
759 		btrfs_err(fs_info, "zoned: mixed block groups not supported");
760 		return -EINVAL;
761 	}
762 
763 	fs_info->zone_size = zone_size;
764 	/*
765 	 * Also limit max_zone_append_size by max_segments * PAGE_SIZE.
766 	 * Technically, we can have multiple pages per segment. But, since
767 	 * we add the pages one by one to a bio, and cannot increase the
768 	 * metadata reservation even if it increases the number of extents, it
769 	 * is safe to stick with the limit.
770 	 */
771 	fs_info->max_zone_append_size = ALIGN_DOWN(
772 		min3((u64)lim->max_zone_append_sectors << SECTOR_SHIFT,
773 		     (u64)lim->max_sectors << SECTOR_SHIFT,
774 		     (u64)lim->max_segments << PAGE_SHIFT),
775 		fs_info->sectorsize);
776 	fs_info->fs_devices->chunk_alloc_policy = BTRFS_CHUNK_ALLOC_ZONED;
777 	if (fs_info->max_zone_append_size < fs_info->max_extent_size)
778 		fs_info->max_extent_size = fs_info->max_zone_append_size;
779 
780 	/*
781 	 * Check mount options here, because we might change fs_info->zoned
782 	 * from fs_info->zone_size.
783 	 */
784 	ret = btrfs_check_mountopts_zoned(fs_info);
785 	if (ret)
786 		return ret;
787 
788 	btrfs_info(fs_info, "zoned mode enabled with zone size %llu", zone_size);
789 	return 0;
790 }
791 
792 int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info)
793 {
794 	if (!btrfs_is_zoned(info))
795 		return 0;
796 
797 	/*
798 	 * Space cache writing is not COWed. Disable that to avoid write errors
799 	 * in sequential zones.
800 	 */
801 	if (btrfs_test_opt(info, SPACE_CACHE)) {
802 		btrfs_err(info, "zoned: space cache v1 is not supported");
803 		return -EINVAL;
804 	}
805 
806 	if (btrfs_test_opt(info, NODATACOW)) {
807 		btrfs_err(info, "zoned: NODATACOW not supported");
808 		return -EINVAL;
809 	}
810 
811 	btrfs_clear_and_info(info, DISCARD_ASYNC,
812 			"zoned: async discard ignored and disabled for zoned mode");
813 
814 	return 0;
815 }
816 
817 static int sb_log_location(struct block_device *bdev, struct blk_zone *zones,
818 			   int rw, u64 *bytenr_ret)
819 {
820 	u64 wp;
821 	int ret;
822 
823 	if (zones[0].type == BLK_ZONE_TYPE_CONVENTIONAL) {
824 		*bytenr_ret = zones[0].start << SECTOR_SHIFT;
825 		return 0;
826 	}
827 
828 	ret = sb_write_pointer(bdev, zones, &wp);
829 	if (ret != -ENOENT && ret < 0)
830 		return ret;
831 
832 	if (rw == WRITE) {
833 		struct blk_zone *reset = NULL;
834 
835 		if (wp == zones[0].start << SECTOR_SHIFT)
836 			reset = &zones[0];
837 		else if (wp == zones[1].start << SECTOR_SHIFT)
838 			reset = &zones[1];
839 
840 		if (reset && reset->cond != BLK_ZONE_COND_EMPTY) {
841 			ASSERT(sb_zone_is_full(reset));
842 
843 			ret = blkdev_zone_mgmt(bdev, REQ_OP_ZONE_RESET,
844 					       reset->start, reset->len,
845 					       GFP_NOFS);
846 			if (ret)
847 				return ret;
848 
849 			reset->cond = BLK_ZONE_COND_EMPTY;
850 			reset->wp = reset->start;
851 		}
852 	} else if (ret != -ENOENT) {
853 		/*
854 		 * For READ, we want the previous one. Move write pointer to
855 		 * the end of a zone, if it is at the head of a zone.
856 		 */
857 		u64 zone_end = 0;
858 
859 		if (wp == zones[0].start << SECTOR_SHIFT)
860 			zone_end = zones[1].start + zones[1].capacity;
861 		else if (wp == zones[1].start << SECTOR_SHIFT)
862 			zone_end = zones[0].start + zones[0].capacity;
863 		if (zone_end)
864 			wp = ALIGN_DOWN(zone_end << SECTOR_SHIFT,
865 					BTRFS_SUPER_INFO_SIZE);
866 
867 		wp -= BTRFS_SUPER_INFO_SIZE;
868 	}
869 
870 	*bytenr_ret = wp;
871 	return 0;
872 
873 }
874 
875 int btrfs_sb_log_location_bdev(struct block_device *bdev, int mirror, int rw,
876 			       u64 *bytenr_ret)
877 {
878 	struct blk_zone zones[BTRFS_NR_SB_LOG_ZONES];
879 	sector_t zone_sectors;
880 	u32 sb_zone;
881 	int ret;
882 	u8 zone_sectors_shift;
883 	sector_t nr_sectors;
884 	u32 nr_zones;
885 
886 	if (!bdev_is_zoned(bdev)) {
887 		*bytenr_ret = btrfs_sb_offset(mirror);
888 		return 0;
889 	}
890 
891 	ASSERT(rw == READ || rw == WRITE);
892 
893 	zone_sectors = bdev_zone_sectors(bdev);
894 	if (!is_power_of_2(zone_sectors))
895 		return -EINVAL;
896 	zone_sectors_shift = ilog2(zone_sectors);
897 	nr_sectors = bdev_nr_sectors(bdev);
898 	nr_zones = nr_sectors >> zone_sectors_shift;
899 
900 	sb_zone = sb_zone_number(zone_sectors_shift + SECTOR_SHIFT, mirror);
901 	if (sb_zone + 1 >= nr_zones)
902 		return -ENOENT;
903 
904 	ret = blkdev_report_zones(bdev, zone_start_sector(sb_zone, bdev),
905 				  BTRFS_NR_SB_LOG_ZONES, copy_zone_info_cb,
906 				  zones);
907 	if (ret < 0)
908 		return ret;
909 	if (ret != BTRFS_NR_SB_LOG_ZONES)
910 		return -EIO;
911 
912 	return sb_log_location(bdev, zones, rw, bytenr_ret);
913 }
914 
915 int btrfs_sb_log_location(struct btrfs_device *device, int mirror, int rw,
916 			  u64 *bytenr_ret)
917 {
918 	struct btrfs_zoned_device_info *zinfo = device->zone_info;
919 	u32 zone_num;
920 
921 	/*
922 	 * For a zoned filesystem on a non-zoned block device, use the same
923 	 * super block locations as regular filesystem. Doing so, the super
924 	 * block can always be retrieved and the zoned flag of the volume
925 	 * detected from the super block information.
926 	 */
927 	if (!bdev_is_zoned(device->bdev)) {
928 		*bytenr_ret = btrfs_sb_offset(mirror);
929 		return 0;
930 	}
931 
932 	zone_num = sb_zone_number(zinfo->zone_size_shift, mirror);
933 	if (zone_num + 1 >= zinfo->nr_zones)
934 		return -ENOENT;
935 
936 	return sb_log_location(device->bdev,
937 			       &zinfo->sb_zones[BTRFS_NR_SB_LOG_ZONES * mirror],
938 			       rw, bytenr_ret);
939 }
940 
941 static inline bool is_sb_log_zone(struct btrfs_zoned_device_info *zinfo,
942 				  int mirror)
943 {
944 	u32 zone_num;
945 
946 	if (!zinfo)
947 		return false;
948 
949 	zone_num = sb_zone_number(zinfo->zone_size_shift, mirror);
950 	if (zone_num + 1 >= zinfo->nr_zones)
951 		return false;
952 
953 	if (!test_bit(zone_num, zinfo->seq_zones))
954 		return false;
955 
956 	return true;
957 }
958 
959 int btrfs_advance_sb_log(struct btrfs_device *device, int mirror)
960 {
961 	struct btrfs_zoned_device_info *zinfo = device->zone_info;
962 	struct blk_zone *zone;
963 	int i;
964 
965 	if (!is_sb_log_zone(zinfo, mirror))
966 		return 0;
967 
968 	zone = &zinfo->sb_zones[BTRFS_NR_SB_LOG_ZONES * mirror];
969 	for (i = 0; i < BTRFS_NR_SB_LOG_ZONES; i++) {
970 		/* Advance the next zone */
971 		if (zone->cond == BLK_ZONE_COND_FULL) {
972 			zone++;
973 			continue;
974 		}
975 
976 		if (zone->cond == BLK_ZONE_COND_EMPTY)
977 			zone->cond = BLK_ZONE_COND_IMP_OPEN;
978 
979 		zone->wp += SUPER_INFO_SECTORS;
980 
981 		if (sb_zone_is_full(zone)) {
982 			/*
983 			 * No room left to write new superblock. Since
984 			 * superblock is written with REQ_SYNC, it is safe to
985 			 * finish the zone now.
986 			 *
987 			 * If the write pointer is exactly at the capacity,
988 			 * explicit ZONE_FINISH is not necessary.
989 			 */
990 			if (zone->wp != zone->start + zone->capacity) {
991 				int ret;
992 
993 				ret = blkdev_zone_mgmt(device->bdev,
994 						REQ_OP_ZONE_FINISH, zone->start,
995 						zone->len, GFP_NOFS);
996 				if (ret)
997 					return ret;
998 			}
999 
1000 			zone->wp = zone->start + zone->len;
1001 			zone->cond = BLK_ZONE_COND_FULL;
1002 		}
1003 		return 0;
1004 	}
1005 
1006 	/* All the zones are FULL. Should not reach here. */
1007 	ASSERT(0);
1008 	return -EIO;
1009 }
1010 
1011 int btrfs_reset_sb_log_zones(struct block_device *bdev, int mirror)
1012 {
1013 	sector_t zone_sectors;
1014 	sector_t nr_sectors;
1015 	u8 zone_sectors_shift;
1016 	u32 sb_zone;
1017 	u32 nr_zones;
1018 
1019 	zone_sectors = bdev_zone_sectors(bdev);
1020 	zone_sectors_shift = ilog2(zone_sectors);
1021 	nr_sectors = bdev_nr_sectors(bdev);
1022 	nr_zones = nr_sectors >> zone_sectors_shift;
1023 
1024 	sb_zone = sb_zone_number(zone_sectors_shift + SECTOR_SHIFT, mirror);
1025 	if (sb_zone + 1 >= nr_zones)
1026 		return -ENOENT;
1027 
1028 	return blkdev_zone_mgmt(bdev, REQ_OP_ZONE_RESET,
1029 				zone_start_sector(sb_zone, bdev),
1030 				zone_sectors * BTRFS_NR_SB_LOG_ZONES, GFP_NOFS);
1031 }
1032 
1033 /*
1034  * Find allocatable zones within a given region.
1035  *
1036  * @device:	the device to allocate a region on
1037  * @hole_start: the position of the hole to allocate the region
1038  * @num_bytes:	size of wanted region
1039  * @hole_end:	the end of the hole
1040  * @return:	position of allocatable zones
1041  *
1042  * Allocatable region should not contain any superblock locations.
1043  */
1044 u64 btrfs_find_allocatable_zones(struct btrfs_device *device, u64 hole_start,
1045 				 u64 hole_end, u64 num_bytes)
1046 {
1047 	struct btrfs_zoned_device_info *zinfo = device->zone_info;
1048 	const u8 shift = zinfo->zone_size_shift;
1049 	u64 nzones = num_bytes >> shift;
1050 	u64 pos = hole_start;
1051 	u64 begin, end;
1052 	bool have_sb;
1053 	int i;
1054 
1055 	ASSERT(IS_ALIGNED(hole_start, zinfo->zone_size));
1056 	ASSERT(IS_ALIGNED(num_bytes, zinfo->zone_size));
1057 
1058 	while (pos < hole_end) {
1059 		begin = pos >> shift;
1060 		end = begin + nzones;
1061 
1062 		if (end > zinfo->nr_zones)
1063 			return hole_end;
1064 
1065 		/* Check if zones in the region are all empty */
1066 		if (btrfs_dev_is_sequential(device, pos) &&
1067 		    !bitmap_test_range_all_set(zinfo->empty_zones, begin, nzones)) {
1068 			pos += zinfo->zone_size;
1069 			continue;
1070 		}
1071 
1072 		have_sb = false;
1073 		for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1074 			u32 sb_zone;
1075 			u64 sb_pos;
1076 
1077 			sb_zone = sb_zone_number(shift, i);
1078 			if (!(end <= sb_zone ||
1079 			      sb_zone + BTRFS_NR_SB_LOG_ZONES <= begin)) {
1080 				have_sb = true;
1081 				pos = zone_start_physical(
1082 					sb_zone + BTRFS_NR_SB_LOG_ZONES, zinfo);
1083 				break;
1084 			}
1085 
1086 			/* We also need to exclude regular superblock positions */
1087 			sb_pos = btrfs_sb_offset(i);
1088 			if (!(pos + num_bytes <= sb_pos ||
1089 			      sb_pos + BTRFS_SUPER_INFO_SIZE <= pos)) {
1090 				have_sb = true;
1091 				pos = ALIGN(sb_pos + BTRFS_SUPER_INFO_SIZE,
1092 					    zinfo->zone_size);
1093 				break;
1094 			}
1095 		}
1096 		if (!have_sb)
1097 			break;
1098 	}
1099 
1100 	return pos;
1101 }
1102 
1103 static bool btrfs_dev_set_active_zone(struct btrfs_device *device, u64 pos)
1104 {
1105 	struct btrfs_zoned_device_info *zone_info = device->zone_info;
1106 	unsigned int zno = (pos >> zone_info->zone_size_shift);
1107 
1108 	/* We can use any number of zones */
1109 	if (zone_info->max_active_zones == 0)
1110 		return true;
1111 
1112 	if (!test_bit(zno, zone_info->active_zones)) {
1113 		/* Active zone left? */
1114 		if (atomic_dec_if_positive(&zone_info->active_zones_left) < 0)
1115 			return false;
1116 		if (test_and_set_bit(zno, zone_info->active_zones)) {
1117 			/* Someone already set the bit */
1118 			atomic_inc(&zone_info->active_zones_left);
1119 		}
1120 	}
1121 
1122 	return true;
1123 }
1124 
1125 static void btrfs_dev_clear_active_zone(struct btrfs_device *device, u64 pos)
1126 {
1127 	struct btrfs_zoned_device_info *zone_info = device->zone_info;
1128 	unsigned int zno = (pos >> zone_info->zone_size_shift);
1129 
1130 	/* We can use any number of zones */
1131 	if (zone_info->max_active_zones == 0)
1132 		return;
1133 
1134 	if (test_and_clear_bit(zno, zone_info->active_zones))
1135 		atomic_inc(&zone_info->active_zones_left);
1136 }
1137 
1138 int btrfs_reset_device_zone(struct btrfs_device *device, u64 physical,
1139 			    u64 length, u64 *bytes)
1140 {
1141 	int ret;
1142 
1143 	*bytes = 0;
1144 	ret = blkdev_zone_mgmt(device->bdev, REQ_OP_ZONE_RESET,
1145 			       physical >> SECTOR_SHIFT, length >> SECTOR_SHIFT,
1146 			       GFP_NOFS);
1147 	if (ret)
1148 		return ret;
1149 
1150 	*bytes = length;
1151 	while (length) {
1152 		btrfs_dev_set_zone_empty(device, physical);
1153 		btrfs_dev_clear_active_zone(device, physical);
1154 		physical += device->zone_info->zone_size;
1155 		length -= device->zone_info->zone_size;
1156 	}
1157 
1158 	return 0;
1159 }
1160 
1161 int btrfs_ensure_empty_zones(struct btrfs_device *device, u64 start, u64 size)
1162 {
1163 	struct btrfs_zoned_device_info *zinfo = device->zone_info;
1164 	const u8 shift = zinfo->zone_size_shift;
1165 	unsigned long begin = start >> shift;
1166 	unsigned long nbits = size >> shift;
1167 	u64 pos;
1168 	int ret;
1169 
1170 	ASSERT(IS_ALIGNED(start, zinfo->zone_size));
1171 	ASSERT(IS_ALIGNED(size, zinfo->zone_size));
1172 
1173 	if (begin + nbits > zinfo->nr_zones)
1174 		return -ERANGE;
1175 
1176 	/* All the zones are conventional */
1177 	if (bitmap_test_range_all_zero(zinfo->seq_zones, begin, nbits))
1178 		return 0;
1179 
1180 	/* All the zones are sequential and empty */
1181 	if (bitmap_test_range_all_set(zinfo->seq_zones, begin, nbits) &&
1182 	    bitmap_test_range_all_set(zinfo->empty_zones, begin, nbits))
1183 		return 0;
1184 
1185 	for (pos = start; pos < start + size; pos += zinfo->zone_size) {
1186 		u64 reset_bytes;
1187 
1188 		if (!btrfs_dev_is_sequential(device, pos) ||
1189 		    btrfs_dev_is_empty_zone(device, pos))
1190 			continue;
1191 
1192 		/* Free regions should be empty */
1193 		btrfs_warn_in_rcu(
1194 			device->fs_info,
1195 		"zoned: resetting device %s (devid %llu) zone %llu for allocation",
1196 			rcu_str_deref(device->name), device->devid, pos >> shift);
1197 		WARN_ON_ONCE(1);
1198 
1199 		ret = btrfs_reset_device_zone(device, pos, zinfo->zone_size,
1200 					      &reset_bytes);
1201 		if (ret)
1202 			return ret;
1203 	}
1204 
1205 	return 0;
1206 }
1207 
1208 /*
1209  * Calculate an allocation pointer from the extent allocation information
1210  * for a block group consist of conventional zones. It is pointed to the
1211  * end of the highest addressed extent in the block group as an allocation
1212  * offset.
1213  */
1214 static int calculate_alloc_pointer(struct btrfs_block_group *cache,
1215 				   u64 *offset_ret, bool new)
1216 {
1217 	struct btrfs_fs_info *fs_info = cache->fs_info;
1218 	struct btrfs_root *root;
1219 	struct btrfs_path *path;
1220 	struct btrfs_key key;
1221 	struct btrfs_key found_key;
1222 	int ret;
1223 	u64 length;
1224 
1225 	/*
1226 	 * Avoid  tree lookups for a new block group, there's no use for it.
1227 	 * It must always be 0.
1228 	 *
1229 	 * Also, we have a lock chain of extent buffer lock -> chunk mutex.
1230 	 * For new a block group, this function is called from
1231 	 * btrfs_make_block_group() which is already taking the chunk mutex.
1232 	 * Thus, we cannot call calculate_alloc_pointer() which takes extent
1233 	 * buffer locks to avoid deadlock.
1234 	 */
1235 	if (new) {
1236 		*offset_ret = 0;
1237 		return 0;
1238 	}
1239 
1240 	path = btrfs_alloc_path();
1241 	if (!path)
1242 		return -ENOMEM;
1243 
1244 	key.objectid = cache->start + cache->length;
1245 	key.type = 0;
1246 	key.offset = 0;
1247 
1248 	root = btrfs_extent_root(fs_info, key.objectid);
1249 	ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
1250 	/* We should not find the exact match */
1251 	if (!ret)
1252 		ret = -EUCLEAN;
1253 	if (ret < 0)
1254 		goto out;
1255 
1256 	ret = btrfs_previous_extent_item(root, path, cache->start);
1257 	if (ret) {
1258 		if (ret == 1) {
1259 			ret = 0;
1260 			*offset_ret = 0;
1261 		}
1262 		goto out;
1263 	}
1264 
1265 	btrfs_item_key_to_cpu(path->nodes[0], &found_key, path->slots[0]);
1266 
1267 	if (found_key.type == BTRFS_EXTENT_ITEM_KEY)
1268 		length = found_key.offset;
1269 	else
1270 		length = fs_info->nodesize;
1271 
1272 	if (!(found_key.objectid >= cache->start &&
1273 	       found_key.objectid + length <= cache->start + cache->length)) {
1274 		ret = -EUCLEAN;
1275 		goto out;
1276 	}
1277 	*offset_ret = found_key.objectid + length - cache->start;
1278 	ret = 0;
1279 
1280 out:
1281 	btrfs_free_path(path);
1282 	return ret;
1283 }
1284 
1285 struct zone_info {
1286 	u64 physical;
1287 	u64 capacity;
1288 	u64 alloc_offset;
1289 };
1290 
1291 static int btrfs_load_zone_info(struct btrfs_fs_info *fs_info, int zone_idx,
1292 				struct zone_info *info, unsigned long *active,
1293 				struct map_lookup *map)
1294 {
1295 	struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
1296 	struct btrfs_device *device = map->stripes[zone_idx].dev;
1297 	int dev_replace_is_ongoing = 0;
1298 	unsigned int nofs_flag;
1299 	struct blk_zone zone;
1300 	int ret;
1301 
1302 	info->physical = map->stripes[zone_idx].physical;
1303 
1304 	if (!device->bdev) {
1305 		info->alloc_offset = WP_MISSING_DEV;
1306 		return 0;
1307 	}
1308 
1309 	/* Consider a zone as active if we can allow any number of active zones. */
1310 	if (!device->zone_info->max_active_zones)
1311 		__set_bit(zone_idx, active);
1312 
1313 	if (!btrfs_dev_is_sequential(device, info->physical)) {
1314 		info->alloc_offset = WP_CONVENTIONAL;
1315 		return 0;
1316 	}
1317 
1318 	/* This zone will be used for allocation, so mark this zone non-empty. */
1319 	btrfs_dev_clear_zone_empty(device, info->physical);
1320 
1321 	down_read(&dev_replace->rwsem);
1322 	dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace);
1323 	if (dev_replace_is_ongoing && dev_replace->tgtdev != NULL)
1324 		btrfs_dev_clear_zone_empty(dev_replace->tgtdev, info->physical);
1325 	up_read(&dev_replace->rwsem);
1326 
1327 	/*
1328 	 * The group is mapped to a sequential zone. Get the zone write pointer
1329 	 * to determine the allocation offset within the zone.
1330 	 */
1331 	WARN_ON(!IS_ALIGNED(info->physical, fs_info->zone_size));
1332 	nofs_flag = memalloc_nofs_save();
1333 	ret = btrfs_get_dev_zone(device, info->physical, &zone);
1334 	memalloc_nofs_restore(nofs_flag);
1335 	if (ret) {
1336 		if (ret != -EIO && ret != -EOPNOTSUPP)
1337 			return ret;
1338 		info->alloc_offset = WP_MISSING_DEV;
1339 		return 0;
1340 	}
1341 
1342 	if (zone.type == BLK_ZONE_TYPE_CONVENTIONAL) {
1343 		btrfs_err_in_rcu(fs_info,
1344 		"zoned: unexpected conventional zone %llu on device %s (devid %llu)",
1345 			zone.start << SECTOR_SHIFT, rcu_str_deref(device->name),
1346 			device->devid);
1347 		return -EIO;
1348 	}
1349 
1350 	info->capacity = (zone.capacity << SECTOR_SHIFT);
1351 
1352 	switch (zone.cond) {
1353 	case BLK_ZONE_COND_OFFLINE:
1354 	case BLK_ZONE_COND_READONLY:
1355 		btrfs_err(fs_info,
1356 		"zoned: offline/readonly zone %llu on device %s (devid %llu)",
1357 			  (info->physical >> device->zone_info->zone_size_shift),
1358 			  rcu_str_deref(device->name), device->devid);
1359 		info->alloc_offset = WP_MISSING_DEV;
1360 		break;
1361 	case BLK_ZONE_COND_EMPTY:
1362 		info->alloc_offset = 0;
1363 		break;
1364 	case BLK_ZONE_COND_FULL:
1365 		info->alloc_offset = info->capacity;
1366 		break;
1367 	default:
1368 		/* Partially used zone. */
1369 		info->alloc_offset = ((zone.wp - zone.start) << SECTOR_SHIFT);
1370 		__set_bit(zone_idx, active);
1371 		break;
1372 	}
1373 
1374 	return 0;
1375 }
1376 
1377 static int btrfs_load_block_group_single(struct btrfs_block_group *bg,
1378 					 struct zone_info *info,
1379 					 unsigned long *active)
1380 {
1381 	if (info->alloc_offset == WP_MISSING_DEV) {
1382 		btrfs_err(bg->fs_info,
1383 			"zoned: cannot recover write pointer for zone %llu",
1384 			info->physical);
1385 		return -EIO;
1386 	}
1387 
1388 	bg->alloc_offset = info->alloc_offset;
1389 	bg->zone_capacity = info->capacity;
1390 	if (test_bit(0, active))
1391 		set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &bg->runtime_flags);
1392 	return 0;
1393 }
1394 
1395 static int btrfs_load_block_group_dup(struct btrfs_block_group *bg,
1396 				      struct map_lookup *map,
1397 				      struct zone_info *zone_info,
1398 				      unsigned long *active)
1399 {
1400 	struct btrfs_fs_info *fs_info = bg->fs_info;
1401 
1402 	if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {
1403 		btrfs_err(fs_info, "zoned: data DUP profile needs raid-stripe-tree");
1404 		return -EINVAL;
1405 	}
1406 
1407 	if (zone_info[0].alloc_offset == WP_MISSING_DEV) {
1408 		btrfs_err(bg->fs_info,
1409 			  "zoned: cannot recover write pointer for zone %llu",
1410 			  zone_info[0].physical);
1411 		return -EIO;
1412 	}
1413 	if (zone_info[1].alloc_offset == WP_MISSING_DEV) {
1414 		btrfs_err(bg->fs_info,
1415 			  "zoned: cannot recover write pointer for zone %llu",
1416 			  zone_info[1].physical);
1417 		return -EIO;
1418 	}
1419 	if (zone_info[0].alloc_offset != zone_info[1].alloc_offset) {
1420 		btrfs_err(bg->fs_info,
1421 			  "zoned: write pointer offset mismatch of zones in DUP profile");
1422 		return -EIO;
1423 	}
1424 
1425 	if (test_bit(0, active) != test_bit(1, active)) {
1426 		if (!btrfs_zone_activate(bg))
1427 			return -EIO;
1428 	} else if (test_bit(0, active)) {
1429 		set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &bg->runtime_flags);
1430 	}
1431 
1432 	bg->alloc_offset = zone_info[0].alloc_offset;
1433 	bg->zone_capacity = min(zone_info[0].capacity, zone_info[1].capacity);
1434 	return 0;
1435 }
1436 
1437 static int btrfs_load_block_group_raid1(struct btrfs_block_group *bg,
1438 					struct map_lookup *map,
1439 					struct zone_info *zone_info,
1440 					unsigned long *active)
1441 {
1442 	struct btrfs_fs_info *fs_info = bg->fs_info;
1443 	int i;
1444 
1445 	if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {
1446 		btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",
1447 			  btrfs_bg_type_to_raid_name(map->type));
1448 		return -EINVAL;
1449 	}
1450 
1451 	for (i = 0; i < map->num_stripes; i++) {
1452 		if (zone_info[i].alloc_offset == WP_MISSING_DEV ||
1453 		    zone_info[i].alloc_offset == WP_CONVENTIONAL)
1454 			continue;
1455 
1456 		if ((zone_info[0].alloc_offset != zone_info[i].alloc_offset) &&
1457 		    !btrfs_test_opt(fs_info, DEGRADED)) {
1458 			btrfs_err(fs_info,
1459 			"zoned: write pointer offset mismatch of zones in %s profile",
1460 				  btrfs_bg_type_to_raid_name(map->type));
1461 			return -EIO;
1462 		}
1463 		if (test_bit(0, active) != test_bit(i, active)) {
1464 			if (!btrfs_test_opt(fs_info, DEGRADED) &&
1465 			    !btrfs_zone_activate(bg)) {
1466 				return -EIO;
1467 			}
1468 		} else {
1469 			if (test_bit(0, active))
1470 				set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &bg->runtime_flags);
1471 		}
1472 		/* In case a device is missing we have a cap of 0, so don't use it. */
1473 		bg->zone_capacity = min_not_zero(zone_info[0].capacity,
1474 						 zone_info[1].capacity);
1475 	}
1476 
1477 	if (zone_info[0].alloc_offset != WP_MISSING_DEV)
1478 		bg->alloc_offset = zone_info[0].alloc_offset;
1479 	else
1480 		bg->alloc_offset = zone_info[i - 1].alloc_offset;
1481 
1482 	return 0;
1483 }
1484 
1485 static int btrfs_load_block_group_raid0(struct btrfs_block_group *bg,
1486 					struct map_lookup *map,
1487 					struct zone_info *zone_info,
1488 					unsigned long *active)
1489 {
1490 	struct btrfs_fs_info *fs_info = bg->fs_info;
1491 
1492 	if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {
1493 		btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",
1494 			  btrfs_bg_type_to_raid_name(map->type));
1495 		return -EINVAL;
1496 	}
1497 
1498 	for (int i = 0; i < map->num_stripes; i++) {
1499 		if (zone_info[i].alloc_offset == WP_MISSING_DEV ||
1500 		    zone_info[i].alloc_offset == WP_CONVENTIONAL)
1501 			continue;
1502 
1503 		if (test_bit(0, active) != test_bit(i, active)) {
1504 			if (!btrfs_zone_activate(bg))
1505 				return -EIO;
1506 		} else {
1507 			if (test_bit(0, active))
1508 				set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &bg->runtime_flags);
1509 		}
1510 		bg->zone_capacity += zone_info[i].capacity;
1511 		bg->alloc_offset += zone_info[i].alloc_offset;
1512 	}
1513 
1514 	return 0;
1515 }
1516 
1517 static int btrfs_load_block_group_raid10(struct btrfs_block_group *bg,
1518 					 struct map_lookup *map,
1519 					 struct zone_info *zone_info,
1520 					 unsigned long *active)
1521 {
1522 	struct btrfs_fs_info *fs_info = bg->fs_info;
1523 
1524 	if ((map->type & BTRFS_BLOCK_GROUP_DATA) && !fs_info->stripe_root) {
1525 		btrfs_err(fs_info, "zoned: data %s needs raid-stripe-tree",
1526 			  btrfs_bg_type_to_raid_name(map->type));
1527 		return -EINVAL;
1528 	}
1529 
1530 	for (int i = 0; i < map->num_stripes; i++) {
1531 		if (zone_info[i].alloc_offset == WP_MISSING_DEV ||
1532 		    zone_info[i].alloc_offset == WP_CONVENTIONAL)
1533 			continue;
1534 
1535 		if (test_bit(0, active) != test_bit(i, active)) {
1536 			if (!btrfs_zone_activate(bg))
1537 				return -EIO;
1538 		} else {
1539 			if (test_bit(0, active))
1540 				set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &bg->runtime_flags);
1541 		}
1542 
1543 		if ((i % map->sub_stripes) == 0) {
1544 			bg->zone_capacity += zone_info[i].capacity;
1545 			bg->alloc_offset += zone_info[i].alloc_offset;
1546 		}
1547 	}
1548 
1549 	return 0;
1550 }
1551 
1552 int btrfs_load_block_group_zone_info(struct btrfs_block_group *cache, bool new)
1553 {
1554 	struct btrfs_fs_info *fs_info = cache->fs_info;
1555 	struct extent_map_tree *em_tree = &fs_info->mapping_tree;
1556 	struct extent_map *em;
1557 	struct map_lookup *map;
1558 	u64 logical = cache->start;
1559 	u64 length = cache->length;
1560 	struct zone_info *zone_info = NULL;
1561 	int ret;
1562 	int i;
1563 	unsigned long *active = NULL;
1564 	u64 last_alloc = 0;
1565 	u32 num_sequential = 0, num_conventional = 0;
1566 
1567 	if (!btrfs_is_zoned(fs_info))
1568 		return 0;
1569 
1570 	/* Sanity check */
1571 	if (!IS_ALIGNED(length, fs_info->zone_size)) {
1572 		btrfs_err(fs_info,
1573 		"zoned: block group %llu len %llu unaligned to zone size %llu",
1574 			  logical, length, fs_info->zone_size);
1575 		return -EIO;
1576 	}
1577 
1578 	/* Get the chunk mapping */
1579 	read_lock(&em_tree->lock);
1580 	em = lookup_extent_mapping(em_tree, logical, length);
1581 	read_unlock(&em_tree->lock);
1582 
1583 	if (!em)
1584 		return -EINVAL;
1585 
1586 	map = em->map_lookup;
1587 
1588 	cache->physical_map = kmemdup(map, map_lookup_size(map->num_stripes), GFP_NOFS);
1589 	if (!cache->physical_map) {
1590 		ret = -ENOMEM;
1591 		goto out;
1592 	}
1593 
1594 	zone_info = kcalloc(map->num_stripes, sizeof(*zone_info), GFP_NOFS);
1595 	if (!zone_info) {
1596 		ret = -ENOMEM;
1597 		goto out;
1598 	}
1599 
1600 	active = bitmap_zalloc(map->num_stripes, GFP_NOFS);
1601 	if (!active) {
1602 		ret = -ENOMEM;
1603 		goto out;
1604 	}
1605 
1606 	for (i = 0; i < map->num_stripes; i++) {
1607 		ret = btrfs_load_zone_info(fs_info, i, &zone_info[i], active, map);
1608 		if (ret)
1609 			goto out;
1610 
1611 		if (zone_info[i].alloc_offset == WP_CONVENTIONAL)
1612 			num_conventional++;
1613 		else
1614 			num_sequential++;
1615 	}
1616 
1617 	if (num_sequential > 0)
1618 		set_bit(BLOCK_GROUP_FLAG_SEQUENTIAL_ZONE, &cache->runtime_flags);
1619 
1620 	if (num_conventional > 0) {
1621 		/* Zone capacity is always zone size in emulation */
1622 		cache->zone_capacity = cache->length;
1623 		ret = calculate_alloc_pointer(cache, &last_alloc, new);
1624 		if (ret) {
1625 			btrfs_err(fs_info,
1626 			"zoned: failed to determine allocation offset of bg %llu",
1627 				  cache->start);
1628 			goto out;
1629 		} else if (map->num_stripes == num_conventional) {
1630 			cache->alloc_offset = last_alloc;
1631 			set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &cache->runtime_flags);
1632 			goto out;
1633 		}
1634 	}
1635 
1636 	switch (map->type & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
1637 	case 0: /* single */
1638 		ret = btrfs_load_block_group_single(cache, &zone_info[0], active);
1639 		break;
1640 	case BTRFS_BLOCK_GROUP_DUP:
1641 		ret = btrfs_load_block_group_dup(cache, map, zone_info, active);
1642 		break;
1643 	case BTRFS_BLOCK_GROUP_RAID1:
1644 	case BTRFS_BLOCK_GROUP_RAID1C3:
1645 	case BTRFS_BLOCK_GROUP_RAID1C4:
1646 		ret = btrfs_load_block_group_raid1(cache, map, zone_info, active);
1647 		break;
1648 	case BTRFS_BLOCK_GROUP_RAID0:
1649 		ret = btrfs_load_block_group_raid0(cache, map, zone_info, active);
1650 		break;
1651 	case BTRFS_BLOCK_GROUP_RAID10:
1652 		ret = btrfs_load_block_group_raid10(cache, map, zone_info, active);
1653 		break;
1654 	case BTRFS_BLOCK_GROUP_RAID5:
1655 	case BTRFS_BLOCK_GROUP_RAID6:
1656 	default:
1657 		btrfs_err(fs_info, "zoned: profile %s not yet supported",
1658 			  btrfs_bg_type_to_raid_name(map->type));
1659 		ret = -EINVAL;
1660 		goto out;
1661 	}
1662 
1663 out:
1664 	if (cache->alloc_offset > fs_info->zone_size) {
1665 		btrfs_err(fs_info,
1666 			"zoned: invalid write pointer %llu in block group %llu",
1667 			cache->alloc_offset, cache->start);
1668 		ret = -EIO;
1669 	}
1670 
1671 	if (cache->alloc_offset > cache->zone_capacity) {
1672 		btrfs_err(fs_info,
1673 "zoned: invalid write pointer %llu (larger than zone capacity %llu) in block group %llu",
1674 			  cache->alloc_offset, cache->zone_capacity,
1675 			  cache->start);
1676 		ret = -EIO;
1677 	}
1678 
1679 	/* An extent is allocated after the write pointer */
1680 	if (!ret && num_conventional && last_alloc > cache->alloc_offset) {
1681 		btrfs_err(fs_info,
1682 			  "zoned: got wrong write pointer in BG %llu: %llu > %llu",
1683 			  logical, last_alloc, cache->alloc_offset);
1684 		ret = -EIO;
1685 	}
1686 
1687 	if (!ret) {
1688 		cache->meta_write_pointer = cache->alloc_offset + cache->start;
1689 		if (test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &cache->runtime_flags)) {
1690 			btrfs_get_block_group(cache);
1691 			spin_lock(&fs_info->zone_active_bgs_lock);
1692 			list_add_tail(&cache->active_bg_list,
1693 				      &fs_info->zone_active_bgs);
1694 			spin_unlock(&fs_info->zone_active_bgs_lock);
1695 		}
1696 	} else {
1697 		kfree(cache->physical_map);
1698 		cache->physical_map = NULL;
1699 	}
1700 	bitmap_free(active);
1701 	kfree(zone_info);
1702 	free_extent_map(em);
1703 
1704 	return ret;
1705 }
1706 
1707 void btrfs_calc_zone_unusable(struct btrfs_block_group *cache)
1708 {
1709 	u64 unusable, free;
1710 
1711 	if (!btrfs_is_zoned(cache->fs_info))
1712 		return;
1713 
1714 	WARN_ON(cache->bytes_super != 0);
1715 	unusable = (cache->alloc_offset - cache->used) +
1716 		   (cache->length - cache->zone_capacity);
1717 	free = cache->zone_capacity - cache->alloc_offset;
1718 
1719 	/* We only need ->free_space in ALLOC_SEQ block groups */
1720 	cache->cached = BTRFS_CACHE_FINISHED;
1721 	cache->free_space_ctl->free_space = free;
1722 	cache->zone_unusable = unusable;
1723 }
1724 
1725 void btrfs_redirty_list_add(struct btrfs_transaction *trans,
1726 			    struct extent_buffer *eb)
1727 {
1728 	if (!btrfs_is_zoned(eb->fs_info) ||
1729 	    btrfs_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN))
1730 		return;
1731 
1732 	ASSERT(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
1733 
1734 	memzero_extent_buffer(eb, 0, eb->len);
1735 	set_bit(EXTENT_BUFFER_NO_CHECK, &eb->bflags);
1736 	set_extent_buffer_dirty(eb);
1737 	set_extent_bit(&trans->dirty_pages, eb->start, eb->start + eb->len - 1,
1738 			EXTENT_DIRTY, NULL);
1739 }
1740 
1741 bool btrfs_use_zone_append(struct btrfs_bio *bbio)
1742 {
1743 	u64 start = (bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT);
1744 	struct btrfs_inode *inode = bbio->inode;
1745 	struct btrfs_fs_info *fs_info = bbio->fs_info;
1746 	struct btrfs_block_group *cache;
1747 	bool ret = false;
1748 
1749 	if (!btrfs_is_zoned(fs_info))
1750 		return false;
1751 
1752 	if (!inode || !is_data_inode(&inode->vfs_inode))
1753 		return false;
1754 
1755 	if (btrfs_op(&bbio->bio) != BTRFS_MAP_WRITE)
1756 		return false;
1757 
1758 	/*
1759 	 * Using REQ_OP_ZONE_APPNED for relocation can break assumptions on the
1760 	 * extent layout the relocation code has.
1761 	 * Furthermore we have set aside own block-group from which only the
1762 	 * relocation "process" can allocate and make sure only one process at a
1763 	 * time can add pages to an extent that gets relocated, so it's safe to
1764 	 * use regular REQ_OP_WRITE for this special case.
1765 	 */
1766 	if (btrfs_is_data_reloc_root(inode->root))
1767 		return false;
1768 
1769 	cache = btrfs_lookup_block_group(fs_info, start);
1770 	ASSERT(cache);
1771 	if (!cache)
1772 		return false;
1773 
1774 	ret = !!test_bit(BLOCK_GROUP_FLAG_SEQUENTIAL_ZONE, &cache->runtime_flags);
1775 	btrfs_put_block_group(cache);
1776 
1777 	return ret;
1778 }
1779 
1780 void btrfs_record_physical_zoned(struct btrfs_bio *bbio)
1781 {
1782 	const u64 physical = bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT;
1783 	struct btrfs_ordered_sum *sum = bbio->sums;
1784 
1785 	if (physical < bbio->orig_physical)
1786 		sum->logical -= bbio->orig_physical - physical;
1787 	else
1788 		sum->logical += physical - bbio->orig_physical;
1789 }
1790 
1791 static void btrfs_rewrite_logical_zoned(struct btrfs_ordered_extent *ordered,
1792 					u64 logical)
1793 {
1794 	struct extent_map_tree *em_tree = &BTRFS_I(ordered->inode)->extent_tree;
1795 	struct extent_map *em;
1796 
1797 	ordered->disk_bytenr = logical;
1798 
1799 	write_lock(&em_tree->lock);
1800 	em = search_extent_mapping(em_tree, ordered->file_offset,
1801 				   ordered->num_bytes);
1802 	em->block_start = logical;
1803 	free_extent_map(em);
1804 	write_unlock(&em_tree->lock);
1805 }
1806 
1807 static bool btrfs_zoned_split_ordered(struct btrfs_ordered_extent *ordered,
1808 				      u64 logical, u64 len)
1809 {
1810 	struct btrfs_ordered_extent *new;
1811 
1812 	if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags) &&
1813 	    split_extent_map(BTRFS_I(ordered->inode), ordered->file_offset,
1814 			     ordered->num_bytes, len, logical))
1815 		return false;
1816 
1817 	new = btrfs_split_ordered_extent(ordered, len);
1818 	if (IS_ERR(new))
1819 		return false;
1820 	new->disk_bytenr = logical;
1821 	btrfs_finish_one_ordered(new);
1822 	return true;
1823 }
1824 
1825 void btrfs_finish_ordered_zoned(struct btrfs_ordered_extent *ordered)
1826 {
1827 	struct btrfs_inode *inode = BTRFS_I(ordered->inode);
1828 	struct btrfs_fs_info *fs_info = inode->root->fs_info;
1829 	struct btrfs_ordered_sum *sum;
1830 	u64 logical, len;
1831 
1832 	/*
1833 	 * Write to pre-allocated region is for the data relocation, and so
1834 	 * it should use WRITE operation. No split/rewrite are necessary.
1835 	 */
1836 	if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags))
1837 		return;
1838 
1839 	ASSERT(!list_empty(&ordered->list));
1840 	/* The ordered->list can be empty in the above pre-alloc case. */
1841 	sum = list_first_entry(&ordered->list, struct btrfs_ordered_sum, list);
1842 	logical = sum->logical;
1843 	len = sum->len;
1844 
1845 	while (len < ordered->disk_num_bytes) {
1846 		sum = list_next_entry(sum, list);
1847 		if (sum->logical == logical + len) {
1848 			len += sum->len;
1849 			continue;
1850 		}
1851 		if (!btrfs_zoned_split_ordered(ordered, logical, len)) {
1852 			set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
1853 			btrfs_err(fs_info, "failed to split ordered extent");
1854 			goto out;
1855 		}
1856 		logical = sum->logical;
1857 		len = sum->len;
1858 	}
1859 
1860 	if (ordered->disk_bytenr != logical)
1861 		btrfs_rewrite_logical_zoned(ordered, logical);
1862 
1863 out:
1864 	/*
1865 	 * If we end up here for nodatasum I/O, the btrfs_ordered_sum structures
1866 	 * were allocated by btrfs_alloc_dummy_sum only to record the logical
1867 	 * addresses and don't contain actual checksums.  We thus must free them
1868 	 * here so that we don't attempt to log the csums later.
1869 	 */
1870 	if ((inode->flags & BTRFS_INODE_NODATASUM) ||
1871 	    test_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state)) {
1872 		while ((sum = list_first_entry_or_null(&ordered->list,
1873 						       typeof(*sum), list))) {
1874 			list_del(&sum->list);
1875 			kfree(sum);
1876 		}
1877 	}
1878 }
1879 
1880 static bool check_bg_is_active(struct btrfs_eb_write_context *ctx,
1881 			       struct btrfs_block_group **active_bg)
1882 {
1883 	const struct writeback_control *wbc = ctx->wbc;
1884 	struct btrfs_block_group *block_group = ctx->zoned_bg;
1885 	struct btrfs_fs_info *fs_info = block_group->fs_info;
1886 
1887 	if (test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags))
1888 		return true;
1889 
1890 	if (fs_info->treelog_bg == block_group->start) {
1891 		if (!btrfs_zone_activate(block_group)) {
1892 			int ret_fin = btrfs_zone_finish_one_bg(fs_info);
1893 
1894 			if (ret_fin != 1 || !btrfs_zone_activate(block_group))
1895 				return false;
1896 		}
1897 	} else if (*active_bg != block_group) {
1898 		struct btrfs_block_group *tgt = *active_bg;
1899 
1900 		/* zoned_meta_io_lock protects fs_info->active_{meta,system}_bg. */
1901 		lockdep_assert_held(&fs_info->zoned_meta_io_lock);
1902 
1903 		if (tgt) {
1904 			/*
1905 			 * If there is an unsent IO left in the allocated area,
1906 			 * we cannot wait for them as it may cause a deadlock.
1907 			 */
1908 			if (tgt->meta_write_pointer < tgt->start + tgt->alloc_offset) {
1909 				if (wbc->sync_mode == WB_SYNC_NONE ||
1910 				    (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync))
1911 					return false;
1912 			}
1913 
1914 			/* Pivot active metadata/system block group. */
1915 			btrfs_zoned_meta_io_unlock(fs_info);
1916 			wait_eb_writebacks(tgt);
1917 			do_zone_finish(tgt, true);
1918 			btrfs_zoned_meta_io_lock(fs_info);
1919 			if (*active_bg == tgt) {
1920 				btrfs_put_block_group(tgt);
1921 				*active_bg = NULL;
1922 			}
1923 		}
1924 		if (!btrfs_zone_activate(block_group))
1925 			return false;
1926 		if (*active_bg != block_group) {
1927 			ASSERT(*active_bg == NULL);
1928 			*active_bg = block_group;
1929 			btrfs_get_block_group(block_group);
1930 		}
1931 	}
1932 
1933 	return true;
1934 }
1935 
1936 /*
1937  * Check if @ctx->eb is aligned to the write pointer.
1938  *
1939  * Return:
1940  *   0:        @ctx->eb is at the write pointer. You can write it.
1941  *   -EAGAIN:  There is a hole. The caller should handle the case.
1942  *   -EBUSY:   There is a hole, but the caller can just bail out.
1943  */
1944 int btrfs_check_meta_write_pointer(struct btrfs_fs_info *fs_info,
1945 				   struct btrfs_eb_write_context *ctx)
1946 {
1947 	const struct writeback_control *wbc = ctx->wbc;
1948 	const struct extent_buffer *eb = ctx->eb;
1949 	struct btrfs_block_group *block_group = ctx->zoned_bg;
1950 
1951 	if (!btrfs_is_zoned(fs_info))
1952 		return 0;
1953 
1954 	if (block_group) {
1955 		if (block_group->start > eb->start ||
1956 		    block_group->start + block_group->length <= eb->start) {
1957 			btrfs_put_block_group(block_group);
1958 			block_group = NULL;
1959 			ctx->zoned_bg = NULL;
1960 		}
1961 	}
1962 
1963 	if (!block_group) {
1964 		block_group = btrfs_lookup_block_group(fs_info, eb->start);
1965 		if (!block_group)
1966 			return 0;
1967 		ctx->zoned_bg = block_group;
1968 	}
1969 
1970 	if (block_group->meta_write_pointer == eb->start) {
1971 		struct btrfs_block_group **tgt;
1972 
1973 		if (!test_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags))
1974 			return 0;
1975 
1976 		if (block_group->flags & BTRFS_BLOCK_GROUP_SYSTEM)
1977 			tgt = &fs_info->active_system_bg;
1978 		else
1979 			tgt = &fs_info->active_meta_bg;
1980 		if (check_bg_is_active(ctx, tgt))
1981 			return 0;
1982 	}
1983 
1984 	/*
1985 	 * Since we may release fs_info->zoned_meta_io_lock, someone can already
1986 	 * start writing this eb. In that case, we can just bail out.
1987 	 */
1988 	if (block_group->meta_write_pointer > eb->start)
1989 		return -EBUSY;
1990 
1991 	/* If for_sync, this hole will be filled with trasnsaction commit. */
1992 	if (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync)
1993 		return -EAGAIN;
1994 	return -EBUSY;
1995 }
1996 
1997 int btrfs_zoned_issue_zeroout(struct btrfs_device *device, u64 physical, u64 length)
1998 {
1999 	if (!btrfs_dev_is_sequential(device, physical))
2000 		return -EOPNOTSUPP;
2001 
2002 	return blkdev_issue_zeroout(device->bdev, physical >> SECTOR_SHIFT,
2003 				    length >> SECTOR_SHIFT, GFP_NOFS, 0);
2004 }
2005 
2006 static int read_zone_info(struct btrfs_fs_info *fs_info, u64 logical,
2007 			  struct blk_zone *zone)
2008 {
2009 	struct btrfs_io_context *bioc = NULL;
2010 	u64 mapped_length = PAGE_SIZE;
2011 	unsigned int nofs_flag;
2012 	int nmirrors;
2013 	int i, ret;
2014 
2015 	ret = btrfs_map_block(fs_info, BTRFS_MAP_GET_READ_MIRRORS, logical,
2016 			      &mapped_length, &bioc, NULL, NULL);
2017 	if (ret || !bioc || mapped_length < PAGE_SIZE) {
2018 		ret = -EIO;
2019 		goto out_put_bioc;
2020 	}
2021 
2022 	if (bioc->map_type & BTRFS_BLOCK_GROUP_RAID56_MASK) {
2023 		ret = -EINVAL;
2024 		goto out_put_bioc;
2025 	}
2026 
2027 	nofs_flag = memalloc_nofs_save();
2028 	nmirrors = (int)bioc->num_stripes;
2029 	for (i = 0; i < nmirrors; i++) {
2030 		u64 physical = bioc->stripes[i].physical;
2031 		struct btrfs_device *dev = bioc->stripes[i].dev;
2032 
2033 		/* Missing device */
2034 		if (!dev->bdev)
2035 			continue;
2036 
2037 		ret = btrfs_get_dev_zone(dev, physical, zone);
2038 		/* Failing device */
2039 		if (ret == -EIO || ret == -EOPNOTSUPP)
2040 			continue;
2041 		break;
2042 	}
2043 	memalloc_nofs_restore(nofs_flag);
2044 out_put_bioc:
2045 	btrfs_put_bioc(bioc);
2046 	return ret;
2047 }
2048 
2049 /*
2050  * Synchronize write pointer in a zone at @physical_start on @tgt_dev, by
2051  * filling zeros between @physical_pos to a write pointer of dev-replace
2052  * source device.
2053  */
2054 int btrfs_sync_zone_write_pointer(struct btrfs_device *tgt_dev, u64 logical,
2055 				    u64 physical_start, u64 physical_pos)
2056 {
2057 	struct btrfs_fs_info *fs_info = tgt_dev->fs_info;
2058 	struct blk_zone zone;
2059 	u64 length;
2060 	u64 wp;
2061 	int ret;
2062 
2063 	if (!btrfs_dev_is_sequential(tgt_dev, physical_pos))
2064 		return 0;
2065 
2066 	ret = read_zone_info(fs_info, logical, &zone);
2067 	if (ret)
2068 		return ret;
2069 
2070 	wp = physical_start + ((zone.wp - zone.start) << SECTOR_SHIFT);
2071 
2072 	if (physical_pos == wp)
2073 		return 0;
2074 
2075 	if (physical_pos > wp)
2076 		return -EUCLEAN;
2077 
2078 	length = wp - physical_pos;
2079 	return btrfs_zoned_issue_zeroout(tgt_dev, physical_pos, length);
2080 }
2081 
2082 /*
2083  * Activate block group and underlying device zones
2084  *
2085  * @block_group: the block group to activate
2086  *
2087  * Return: true on success, false otherwise
2088  */
2089 bool btrfs_zone_activate(struct btrfs_block_group *block_group)
2090 {
2091 	struct btrfs_fs_info *fs_info = block_group->fs_info;
2092 	struct map_lookup *map;
2093 	struct btrfs_device *device;
2094 	u64 physical;
2095 	const bool is_data = (block_group->flags & BTRFS_BLOCK_GROUP_DATA);
2096 	bool ret;
2097 	int i;
2098 
2099 	if (!btrfs_is_zoned(block_group->fs_info))
2100 		return true;
2101 
2102 	map = block_group->physical_map;
2103 
2104 	spin_lock(&block_group->lock);
2105 	if (test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags)) {
2106 		ret = true;
2107 		goto out_unlock;
2108 	}
2109 
2110 	/* No space left */
2111 	if (btrfs_zoned_bg_is_full(block_group)) {
2112 		ret = false;
2113 		goto out_unlock;
2114 	}
2115 
2116 	spin_lock(&fs_info->zone_active_bgs_lock);
2117 	for (i = 0; i < map->num_stripes; i++) {
2118 		struct btrfs_zoned_device_info *zinfo;
2119 		int reserved = 0;
2120 
2121 		device = map->stripes[i].dev;
2122 		physical = map->stripes[i].physical;
2123 		zinfo = device->zone_info;
2124 
2125 		if (zinfo->max_active_zones == 0)
2126 			continue;
2127 
2128 		if (is_data)
2129 			reserved = zinfo->reserved_active_zones;
2130 		/*
2131 		 * For the data block group, leave active zones for one
2132 		 * metadata block group and one system block group.
2133 		 */
2134 		if (atomic_read(&zinfo->active_zones_left) <= reserved) {
2135 			ret = false;
2136 			spin_unlock(&fs_info->zone_active_bgs_lock);
2137 			goto out_unlock;
2138 		}
2139 
2140 		if (!btrfs_dev_set_active_zone(device, physical)) {
2141 			/* Cannot activate the zone */
2142 			ret = false;
2143 			spin_unlock(&fs_info->zone_active_bgs_lock);
2144 			goto out_unlock;
2145 		}
2146 		if (!is_data)
2147 			zinfo->reserved_active_zones--;
2148 	}
2149 	spin_unlock(&fs_info->zone_active_bgs_lock);
2150 
2151 	/* Successfully activated all the zones */
2152 	set_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags);
2153 	spin_unlock(&block_group->lock);
2154 
2155 	/* For the active block group list */
2156 	btrfs_get_block_group(block_group);
2157 
2158 	spin_lock(&fs_info->zone_active_bgs_lock);
2159 	list_add_tail(&block_group->active_bg_list, &fs_info->zone_active_bgs);
2160 	spin_unlock(&fs_info->zone_active_bgs_lock);
2161 
2162 	return true;
2163 
2164 out_unlock:
2165 	spin_unlock(&block_group->lock);
2166 	return ret;
2167 }
2168 
2169 static void wait_eb_writebacks(struct btrfs_block_group *block_group)
2170 {
2171 	struct btrfs_fs_info *fs_info = block_group->fs_info;
2172 	const u64 end = block_group->start + block_group->length;
2173 	struct radix_tree_iter iter;
2174 	struct extent_buffer *eb;
2175 	void __rcu **slot;
2176 
2177 	rcu_read_lock();
2178 	radix_tree_for_each_slot(slot, &fs_info->buffer_radix, &iter,
2179 				 block_group->start >> fs_info->sectorsize_bits) {
2180 		eb = radix_tree_deref_slot(slot);
2181 		if (!eb)
2182 			continue;
2183 		if (radix_tree_deref_retry(eb)) {
2184 			slot = radix_tree_iter_retry(&iter);
2185 			continue;
2186 		}
2187 
2188 		if (eb->start < block_group->start)
2189 			continue;
2190 		if (eb->start >= end)
2191 			break;
2192 
2193 		slot = radix_tree_iter_resume(slot, &iter);
2194 		rcu_read_unlock();
2195 		wait_on_extent_buffer_writeback(eb);
2196 		rcu_read_lock();
2197 	}
2198 	rcu_read_unlock();
2199 }
2200 
2201 static int do_zone_finish(struct btrfs_block_group *block_group, bool fully_written)
2202 {
2203 	struct btrfs_fs_info *fs_info = block_group->fs_info;
2204 	struct map_lookup *map;
2205 	const bool is_metadata = (block_group->flags &
2206 			(BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_SYSTEM));
2207 	int ret = 0;
2208 	int i;
2209 
2210 	spin_lock(&block_group->lock);
2211 	if (!test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags)) {
2212 		spin_unlock(&block_group->lock);
2213 		return 0;
2214 	}
2215 
2216 	/* Check if we have unwritten allocated space */
2217 	if (is_metadata &&
2218 	    block_group->start + block_group->alloc_offset > block_group->meta_write_pointer) {
2219 		spin_unlock(&block_group->lock);
2220 		return -EAGAIN;
2221 	}
2222 
2223 	/*
2224 	 * If we are sure that the block group is full (= no more room left for
2225 	 * new allocation) and the IO for the last usable block is completed, we
2226 	 * don't need to wait for the other IOs. This holds because we ensure
2227 	 * the sequential IO submissions using the ZONE_APPEND command for data
2228 	 * and block_group->meta_write_pointer for metadata.
2229 	 */
2230 	if (!fully_written) {
2231 		if (test_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, &block_group->runtime_flags)) {
2232 			spin_unlock(&block_group->lock);
2233 			return -EAGAIN;
2234 		}
2235 		spin_unlock(&block_group->lock);
2236 
2237 		ret = btrfs_inc_block_group_ro(block_group, false);
2238 		if (ret)
2239 			return ret;
2240 
2241 		/* Ensure all writes in this block group finish */
2242 		btrfs_wait_block_group_reservations(block_group);
2243 		/* No need to wait for NOCOW writers. Zoned mode does not allow that */
2244 		btrfs_wait_ordered_roots(fs_info, U64_MAX, block_group->start,
2245 					 block_group->length);
2246 		/* Wait for extent buffers to be written. */
2247 		if (is_metadata)
2248 			wait_eb_writebacks(block_group);
2249 
2250 		spin_lock(&block_group->lock);
2251 
2252 		/*
2253 		 * Bail out if someone already deactivated the block group, or
2254 		 * allocated space is left in the block group.
2255 		 */
2256 		if (!test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE,
2257 			      &block_group->runtime_flags)) {
2258 			spin_unlock(&block_group->lock);
2259 			btrfs_dec_block_group_ro(block_group);
2260 			return 0;
2261 		}
2262 
2263 		if (block_group->reserved ||
2264 		    test_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC,
2265 			     &block_group->runtime_flags)) {
2266 			spin_unlock(&block_group->lock);
2267 			btrfs_dec_block_group_ro(block_group);
2268 			return -EAGAIN;
2269 		}
2270 	}
2271 
2272 	clear_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE, &block_group->runtime_flags);
2273 	block_group->alloc_offset = block_group->zone_capacity;
2274 	if (block_group->flags & (BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_SYSTEM))
2275 		block_group->meta_write_pointer = block_group->start +
2276 						  block_group->zone_capacity;
2277 	block_group->free_space_ctl->free_space = 0;
2278 	btrfs_clear_treelog_bg(block_group);
2279 	btrfs_clear_data_reloc_bg(block_group);
2280 	spin_unlock(&block_group->lock);
2281 
2282 	map = block_group->physical_map;
2283 	for (i = 0; i < map->num_stripes; i++) {
2284 		struct btrfs_device *device = map->stripes[i].dev;
2285 		const u64 physical = map->stripes[i].physical;
2286 		struct btrfs_zoned_device_info *zinfo = device->zone_info;
2287 
2288 		if (zinfo->max_active_zones == 0)
2289 			continue;
2290 
2291 		ret = blkdev_zone_mgmt(device->bdev, REQ_OP_ZONE_FINISH,
2292 				       physical >> SECTOR_SHIFT,
2293 				       zinfo->zone_size >> SECTOR_SHIFT,
2294 				       GFP_NOFS);
2295 
2296 		if (ret)
2297 			return ret;
2298 
2299 		if (!(block_group->flags & BTRFS_BLOCK_GROUP_DATA))
2300 			zinfo->reserved_active_zones++;
2301 		btrfs_dev_clear_active_zone(device, physical);
2302 	}
2303 
2304 	if (!fully_written)
2305 		btrfs_dec_block_group_ro(block_group);
2306 
2307 	spin_lock(&fs_info->zone_active_bgs_lock);
2308 	ASSERT(!list_empty(&block_group->active_bg_list));
2309 	list_del_init(&block_group->active_bg_list);
2310 	spin_unlock(&fs_info->zone_active_bgs_lock);
2311 
2312 	/* For active_bg_list */
2313 	btrfs_put_block_group(block_group);
2314 
2315 	clear_and_wake_up_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags);
2316 
2317 	return 0;
2318 }
2319 
2320 int btrfs_zone_finish(struct btrfs_block_group *block_group)
2321 {
2322 	if (!btrfs_is_zoned(block_group->fs_info))
2323 		return 0;
2324 
2325 	return do_zone_finish(block_group, false);
2326 }
2327 
2328 bool btrfs_can_activate_zone(struct btrfs_fs_devices *fs_devices, u64 flags)
2329 {
2330 	struct btrfs_fs_info *fs_info = fs_devices->fs_info;
2331 	struct btrfs_device *device;
2332 	bool ret = false;
2333 
2334 	if (!btrfs_is_zoned(fs_info))
2335 		return true;
2336 
2337 	/* Check if there is a device with active zones left */
2338 	mutex_lock(&fs_info->chunk_mutex);
2339 	spin_lock(&fs_info->zone_active_bgs_lock);
2340 	list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
2341 		struct btrfs_zoned_device_info *zinfo = device->zone_info;
2342 		int reserved = 0;
2343 
2344 		if (!device->bdev)
2345 			continue;
2346 
2347 		if (!zinfo->max_active_zones) {
2348 			ret = true;
2349 			break;
2350 		}
2351 
2352 		if (flags & BTRFS_BLOCK_GROUP_DATA)
2353 			reserved = zinfo->reserved_active_zones;
2354 
2355 		switch (flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) {
2356 		case 0: /* single */
2357 			ret = (atomic_read(&zinfo->active_zones_left) >= (1 + reserved));
2358 			break;
2359 		case BTRFS_BLOCK_GROUP_DUP:
2360 			ret = (atomic_read(&zinfo->active_zones_left) >= (2 + reserved));
2361 			break;
2362 		}
2363 		if (ret)
2364 			break;
2365 	}
2366 	spin_unlock(&fs_info->zone_active_bgs_lock);
2367 	mutex_unlock(&fs_info->chunk_mutex);
2368 
2369 	if (!ret)
2370 		set_bit(BTRFS_FS_NEED_ZONE_FINISH, &fs_info->flags);
2371 
2372 	return ret;
2373 }
2374 
2375 void btrfs_zone_finish_endio(struct btrfs_fs_info *fs_info, u64 logical, u64 length)
2376 {
2377 	struct btrfs_block_group *block_group;
2378 	u64 min_alloc_bytes;
2379 
2380 	if (!btrfs_is_zoned(fs_info))
2381 		return;
2382 
2383 	block_group = btrfs_lookup_block_group(fs_info, logical);
2384 	ASSERT(block_group);
2385 
2386 	/* No MIXED_BG on zoned btrfs. */
2387 	if (block_group->flags & BTRFS_BLOCK_GROUP_DATA)
2388 		min_alloc_bytes = fs_info->sectorsize;
2389 	else
2390 		min_alloc_bytes = fs_info->nodesize;
2391 
2392 	/* Bail out if we can allocate more data from this block group. */
2393 	if (logical + length + min_alloc_bytes <=
2394 	    block_group->start + block_group->zone_capacity)
2395 		goto out;
2396 
2397 	do_zone_finish(block_group, true);
2398 
2399 out:
2400 	btrfs_put_block_group(block_group);
2401 }
2402 
2403 static void btrfs_zone_finish_endio_workfn(struct work_struct *work)
2404 {
2405 	struct btrfs_block_group *bg =
2406 		container_of(work, struct btrfs_block_group, zone_finish_work);
2407 
2408 	wait_on_extent_buffer_writeback(bg->last_eb);
2409 	free_extent_buffer(bg->last_eb);
2410 	btrfs_zone_finish_endio(bg->fs_info, bg->start, bg->length);
2411 	btrfs_put_block_group(bg);
2412 }
2413 
2414 void btrfs_schedule_zone_finish_bg(struct btrfs_block_group *bg,
2415 				   struct extent_buffer *eb)
2416 {
2417 	if (!test_bit(BLOCK_GROUP_FLAG_SEQUENTIAL_ZONE, &bg->runtime_flags) ||
2418 	    eb->start + eb->len * 2 <= bg->start + bg->zone_capacity)
2419 		return;
2420 
2421 	if (WARN_ON(bg->zone_finish_work.func == btrfs_zone_finish_endio_workfn)) {
2422 		btrfs_err(bg->fs_info, "double scheduling of bg %llu zone finishing",
2423 			  bg->start);
2424 		return;
2425 	}
2426 
2427 	/* For the work */
2428 	btrfs_get_block_group(bg);
2429 	atomic_inc(&eb->refs);
2430 	bg->last_eb = eb;
2431 	INIT_WORK(&bg->zone_finish_work, btrfs_zone_finish_endio_workfn);
2432 	queue_work(system_unbound_wq, &bg->zone_finish_work);
2433 }
2434 
2435 void btrfs_clear_data_reloc_bg(struct btrfs_block_group *bg)
2436 {
2437 	struct btrfs_fs_info *fs_info = bg->fs_info;
2438 
2439 	spin_lock(&fs_info->relocation_bg_lock);
2440 	if (fs_info->data_reloc_bg == bg->start)
2441 		fs_info->data_reloc_bg = 0;
2442 	spin_unlock(&fs_info->relocation_bg_lock);
2443 }
2444 
2445 void btrfs_free_zone_cache(struct btrfs_fs_info *fs_info)
2446 {
2447 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2448 	struct btrfs_device *device;
2449 
2450 	if (!btrfs_is_zoned(fs_info))
2451 		return;
2452 
2453 	mutex_lock(&fs_devices->device_list_mutex);
2454 	list_for_each_entry(device, &fs_devices->devices, dev_list) {
2455 		if (device->zone_info) {
2456 			vfree(device->zone_info->zone_cache);
2457 			device->zone_info->zone_cache = NULL;
2458 		}
2459 	}
2460 	mutex_unlock(&fs_devices->device_list_mutex);
2461 }
2462 
2463 bool btrfs_zoned_should_reclaim(struct btrfs_fs_info *fs_info)
2464 {
2465 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2466 	struct btrfs_device *device;
2467 	u64 used = 0;
2468 	u64 total = 0;
2469 	u64 factor;
2470 
2471 	ASSERT(btrfs_is_zoned(fs_info));
2472 
2473 	if (fs_info->bg_reclaim_threshold == 0)
2474 		return false;
2475 
2476 	mutex_lock(&fs_devices->device_list_mutex);
2477 	list_for_each_entry(device, &fs_devices->devices, dev_list) {
2478 		if (!device->bdev)
2479 			continue;
2480 
2481 		total += device->disk_total_bytes;
2482 		used += device->bytes_used;
2483 	}
2484 	mutex_unlock(&fs_devices->device_list_mutex);
2485 
2486 	factor = div64_u64(used * 100, total);
2487 	return factor >= fs_info->bg_reclaim_threshold;
2488 }
2489 
2490 void btrfs_zoned_release_data_reloc_bg(struct btrfs_fs_info *fs_info, u64 logical,
2491 				       u64 length)
2492 {
2493 	struct btrfs_block_group *block_group;
2494 
2495 	if (!btrfs_is_zoned(fs_info))
2496 		return;
2497 
2498 	block_group = btrfs_lookup_block_group(fs_info, logical);
2499 	/* It should be called on a previous data relocation block group. */
2500 	ASSERT(block_group && (block_group->flags & BTRFS_BLOCK_GROUP_DATA));
2501 
2502 	spin_lock(&block_group->lock);
2503 	if (!test_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, &block_group->runtime_flags))
2504 		goto out;
2505 
2506 	/* All relocation extents are written. */
2507 	if (block_group->start + block_group->alloc_offset == logical + length) {
2508 		/*
2509 		 * Now, release this block group for further allocations and
2510 		 * zone finish.
2511 		 */
2512 		clear_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC,
2513 			  &block_group->runtime_flags);
2514 	}
2515 
2516 out:
2517 	spin_unlock(&block_group->lock);
2518 	btrfs_put_block_group(block_group);
2519 }
2520 
2521 int btrfs_zone_finish_one_bg(struct btrfs_fs_info *fs_info)
2522 {
2523 	struct btrfs_block_group *block_group;
2524 	struct btrfs_block_group *min_bg = NULL;
2525 	u64 min_avail = U64_MAX;
2526 	int ret;
2527 
2528 	spin_lock(&fs_info->zone_active_bgs_lock);
2529 	list_for_each_entry(block_group, &fs_info->zone_active_bgs,
2530 			    active_bg_list) {
2531 		u64 avail;
2532 
2533 		spin_lock(&block_group->lock);
2534 		if (block_group->reserved || block_group->alloc_offset == 0 ||
2535 		    (block_group->flags & BTRFS_BLOCK_GROUP_SYSTEM) ||
2536 		    test_bit(BLOCK_GROUP_FLAG_ZONED_DATA_RELOC, &block_group->runtime_flags)) {
2537 			spin_unlock(&block_group->lock);
2538 			continue;
2539 		}
2540 
2541 		avail = block_group->zone_capacity - block_group->alloc_offset;
2542 		if (min_avail > avail) {
2543 			if (min_bg)
2544 				btrfs_put_block_group(min_bg);
2545 			min_bg = block_group;
2546 			min_avail = avail;
2547 			btrfs_get_block_group(min_bg);
2548 		}
2549 		spin_unlock(&block_group->lock);
2550 	}
2551 	spin_unlock(&fs_info->zone_active_bgs_lock);
2552 
2553 	if (!min_bg)
2554 		return 0;
2555 
2556 	ret = btrfs_zone_finish(min_bg);
2557 	btrfs_put_block_group(min_bg);
2558 
2559 	return ret < 0 ? ret : 1;
2560 }
2561 
2562 int btrfs_zoned_activate_one_bg(struct btrfs_fs_info *fs_info,
2563 				struct btrfs_space_info *space_info,
2564 				bool do_finish)
2565 {
2566 	struct btrfs_block_group *bg;
2567 	int index;
2568 
2569 	if (!btrfs_is_zoned(fs_info) || (space_info->flags & BTRFS_BLOCK_GROUP_DATA))
2570 		return 0;
2571 
2572 	for (;;) {
2573 		int ret;
2574 		bool need_finish = false;
2575 
2576 		down_read(&space_info->groups_sem);
2577 		for (index = 0; index < BTRFS_NR_RAID_TYPES; index++) {
2578 			list_for_each_entry(bg, &space_info->block_groups[index],
2579 					    list) {
2580 				if (!spin_trylock(&bg->lock))
2581 					continue;
2582 				if (btrfs_zoned_bg_is_full(bg) ||
2583 				    test_bit(BLOCK_GROUP_FLAG_ZONE_IS_ACTIVE,
2584 					     &bg->runtime_flags)) {
2585 					spin_unlock(&bg->lock);
2586 					continue;
2587 				}
2588 				spin_unlock(&bg->lock);
2589 
2590 				if (btrfs_zone_activate(bg)) {
2591 					up_read(&space_info->groups_sem);
2592 					return 1;
2593 				}
2594 
2595 				need_finish = true;
2596 			}
2597 		}
2598 		up_read(&space_info->groups_sem);
2599 
2600 		if (!do_finish || !need_finish)
2601 			break;
2602 
2603 		ret = btrfs_zone_finish_one_bg(fs_info);
2604 		if (ret == 0)
2605 			break;
2606 		if (ret < 0)
2607 			return ret;
2608 	}
2609 
2610 	return 0;
2611 }
2612 
2613 /*
2614  * Reserve zones for one metadata block group, one tree-log block group, and one
2615  * system block group.
2616  */
2617 void btrfs_check_active_zone_reservation(struct btrfs_fs_info *fs_info)
2618 {
2619 	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2620 	struct btrfs_block_group *block_group;
2621 	struct btrfs_device *device;
2622 	/* Reserve zones for normal SINGLE metadata and tree-log block group. */
2623 	unsigned int metadata_reserve = 2;
2624 	/* Reserve a zone for SINGLE system block group. */
2625 	unsigned int system_reserve = 1;
2626 
2627 	if (!test_bit(BTRFS_FS_ACTIVE_ZONE_TRACKING, &fs_info->flags))
2628 		return;
2629 
2630 	/*
2631 	 * This function is called from the mount context. So, there is no
2632 	 * parallel process touching the bits. No need for read_seqretry().
2633 	 */
2634 	if (fs_info->avail_metadata_alloc_bits & BTRFS_BLOCK_GROUP_DUP)
2635 		metadata_reserve = 4;
2636 	if (fs_info->avail_system_alloc_bits & BTRFS_BLOCK_GROUP_DUP)
2637 		system_reserve = 2;
2638 
2639 	/* Apply the reservation on all the devices. */
2640 	mutex_lock(&fs_devices->device_list_mutex);
2641 	list_for_each_entry(device, &fs_devices->devices, dev_list) {
2642 		if (!device->bdev)
2643 			continue;
2644 
2645 		device->zone_info->reserved_active_zones =
2646 			metadata_reserve + system_reserve;
2647 	}
2648 	mutex_unlock(&fs_devices->device_list_mutex);
2649 
2650 	/* Release reservation for currently active block groups. */
2651 	spin_lock(&fs_info->zone_active_bgs_lock);
2652 	list_for_each_entry(block_group, &fs_info->zone_active_bgs, active_bg_list) {
2653 		struct map_lookup *map = block_group->physical_map;
2654 
2655 		if (!(block_group->flags &
2656 		      (BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_SYSTEM)))
2657 			continue;
2658 
2659 		for (int i = 0; i < map->num_stripes; i++)
2660 			map->stripes[i].dev->zone_info->reserved_active_zones--;
2661 	}
2662 	spin_unlock(&fs_info->zone_active_bgs_lock);
2663 }
2664