path: root/fs/btrfs/tests/zoned-tests.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2026 Western Digital.  All rights reserved.
 */

#include <linux/cleanup.h>
#include <linux/sizes.h>

#include "btrfs-tests.h"
#include "../space-info.h"
#include "../volumes.h"
#include "../zoned.h"

#define WP_MISSING_DEV				((u64)-1)
#define WP_CONVENTIONAL				((u64)-2)
#define ZONE_SIZE				SZ_256M

#define HALF_STRIPE_LEN				(BTRFS_STRIPE_LEN >> 1)

struct load_zone_info_test_vector {
	u64 raid_type;
	u64 num_stripes;
	u64 alloc_offsets[8];
	u64 last_alloc;
	u64 bg_length;
	bool degraded;

	int expected_result;
	u64 expected_alloc_offset;

	const char *description;
};

struct zone_info {
	u64 physical;
	u64 capacity;
	u64 alloc_offset;
};

static int test_load_zone_info(struct btrfs_fs_info *fs_info,
			       const struct load_zone_info_test_vector *test)
{
	struct btrfs_block_group *bg __free(btrfs_free_dummy_block_group) = NULL;
	struct btrfs_chunk_map *map __free(btrfs_free_chunk_map) = NULL;
	struct zone_info AUTO_KFREE(zone_info);
	unsigned long AUTO_KFREE(active);
	int ret;

	bg = btrfs_alloc_dummy_block_group(fs_info, test->bg_length);
	if (!bg) {
		test_std_err(TEST_ALLOC_BLOCK_GROUP);
		return -ENOMEM;
	}

	map = btrfs_alloc_chunk_map(test->num_stripes, GFP_KERNEL);
	if (!map) {
		test_std_err(TEST_ALLOC_EXTENT_MAP);
		return -ENOMEM;
	}

	zone_info = kzalloc_objs(*zone_info, test->num_stripes, GFP_KERNEL);
	if (!zone_info) {
		test_err("cannot allocate zone info");
		return -ENOMEM;
	}

	active = bitmap_zalloc(test->num_stripes, GFP_KERNEL);
	if (!zone_info) {
		test_err("cannot allocate active bitmap");
		return -ENOMEM;
	}

	map->type = test->raid_type;
	map->num_stripes = test->num_stripes;
	if (test->raid_type == BTRFS_BLOCK_GROUP_RAID10)
		map->sub_stripes = 2;
	for (int i = 0; i < test->num_stripes; i++) {
		zone_info[i].physical = 0;
		zone_info[i].alloc_offset = test->alloc_offsets[i];
		zone_info[i].capacity = ZONE_SIZE;
		if (zone_info[i].alloc_offset && zone_info[i].alloc_offset < ZONE_SIZE)
			__set_bit(i, active);
	}
	if (test->degraded)
		btrfs_set_opt(fs_info->mount_opt, DEGRADED);
	else
		btrfs_clear_opt(fs_info->mount_opt, DEGRADED);

	ret = btrfs_load_block_group_by_raid_type(bg, map, zone_info, active,
						  test->last_alloc);

	if (ret != test->expected_result) {
		test_err("unexpected return value: ret %d expected %d", ret,
			 test->expected_result);
		return -EINVAL;
	}

	if (!ret && bg->alloc_offset != test->expected_alloc_offset) {
		test_err("unexpected alloc_offset: alloc_offset %llu expected %llu",
			 bg->alloc_offset, test->expected_alloc_offset);
		return -EINVAL;
	}

	return 0;
}

static const struct load_zone_info_test_vector load_zone_info_tests[] = {
	/* SINGLE */
	{
		.description = "SINGLE: load write pointer from sequential zone",
		.raid_type = 0,
		.num_stripes = 1,
		.alloc_offsets = {
			SZ_1M,
		},
		.expected_alloc_offset = SZ_1M,
	},
	/*
	 * SINGLE block group on a conventional zone sets last_alloc outside of
	 * btrfs_load_block_group_*(). Do not test that case.
	 */

	/* DUP */
	/* Normal case */
	{
		.description = "DUP: having matching write pointers",
		.raid_type = BTRFS_BLOCK_GROUP_DUP,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, SZ_1M,
		},
		.expected_alloc_offset = SZ_1M,
	},
	/*
	 * One sequential zone and one conventional zone, having matching
	 * last_alloc.
	 */
	{
		.description = "DUP: seq zone and conv zone, matching last_alloc",
		.raid_type = BTRFS_BLOCK_GROUP_DUP,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_CONVENTIONAL,
		},
		.last_alloc = SZ_1M,
		.expected_alloc_offset = SZ_1M,
	},
	/*
	 * One sequential and one conventional zone, but having smaller
	 * last_alloc than write pointer.
	 */
	{
		.description = "DUP: seq zone and conv zone, smaller last_alloc",
		.raid_type = BTRFS_BLOCK_GROUP_DUP,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_CONVENTIONAL,
		},
		.last_alloc = 0,
		.expected_alloc_offset = SZ_1M,
	},
	/* Error case: having different write pointers. */
	{
		.description = "DUP: fail: different write pointers",
		.raid_type = BTRFS_BLOCK_GROUP_DUP,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, SZ_2M,
		},
		.expected_result = -EIO,
	},
	/* Error case: partial missing device should not happen on DUP. */
	{
		.description = "DUP: fail: missing device",
		.raid_type = BTRFS_BLOCK_GROUP_DUP,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_MISSING_DEV,
		},
		.expected_result = -EIO,
	},
	/*
	 * Error case: one sequential and one conventional zone, but having larger
	 * last_alloc than write pointer.
	 */
	{
		.description = "DUP: fail: seq zone and conv zone, larger last_alloc",
		.raid_type = BTRFS_BLOCK_GROUP_DUP,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_CONVENTIONAL,
		},
		.last_alloc = SZ_2M,
		.expected_result = -EIO,
	},

	/* RAID1 */
	/* Normal case */
	{
		.description = "RAID1: having matching write pointers",
		.raid_type = BTRFS_BLOCK_GROUP_RAID1,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, SZ_1M,
		},
		.expected_alloc_offset = SZ_1M,
	},
	/*
	 * One sequential zone and one conventional zone, having matching
	 * last_alloc.
	 */
	{
		.description = "RAID1: seq zone and conv zone, matching last_alloc",
		.raid_type = BTRFS_BLOCK_GROUP_RAID1,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_CONVENTIONAL,
		},
		.last_alloc = SZ_1M,
		.expected_alloc_offset = SZ_1M,
	},
	/*
	 * One sequential and one conventional zone, but having smaller
	 * last_alloc than write pointer.
	 */
	{
		.description = "RAID1: seq zone and conv zone, smaller last_alloc",
		.raid_type = BTRFS_BLOCK_GROUP_RAID1,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_CONVENTIONAL,
		},
		.last_alloc = 0,
		.expected_alloc_offset = SZ_1M,
	},
	/* Partial missing device should be recovered on DEGRADED mount */
	{
		.description = "RAID1: fail: missing device on DEGRADED",
		.raid_type = BTRFS_BLOCK_GROUP_RAID1,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_MISSING_DEV,
		},
		.degraded = true,
		.expected_alloc_offset = SZ_1M,
	},
	/* Error case: having different write pointers. */
	{
		.description = "RAID1: fail: different write pointers",
		.raid_type = BTRFS_BLOCK_GROUP_RAID1,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, SZ_2M,
		},
		.expected_result = -EIO,
	},
	/*
	 * Partial missing device is not allowed on non-DEGRADED mount never happen
	 * as it is rejected beforehand.
	 */
	/*
	 * Error case: one sequential and one conventional zone, but having larger
	 * last_alloc than write pointer.
	 */
	{
		.description = "RAID1: fail: seq zone and conv zone, larger last_alloc",
		.raid_type = BTRFS_BLOCK_GROUP_RAID1,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_CONVENTIONAL,
		},
		.last_alloc = SZ_2M,
		.expected_result = -EIO,
	},

	/* RAID0 */
	/* Normal case */
	{
		.description = "RAID0: initial partial write",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			HALF_STRIPE_LEN, 0, 0, 0,
		},
		.expected_alloc_offset = HALF_STRIPE_LEN,
	},
	{
		.description = "RAID0: while in second stripe",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN + HALF_STRIPE_LEN,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
		},
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 5 + HALF_STRIPE_LEN,
	},
	{
		.description = "RAID0: one stripe advanced",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M + BTRFS_STRIPE_LEN, SZ_1M,
		},
		.expected_alloc_offset = SZ_2M + BTRFS_STRIPE_LEN,
	},
	/* Error case: having different write pointers. */
	{
		.description = "RAID0: fail: disordered stripes",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN * 2,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
		},
		.expected_result = -EIO,
	},
	{
		.description = "RAID0: fail: far distance",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 3, BTRFS_STRIPE_LEN,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
		},
		.expected_result = -EIO,
	},
	{
		.description = "RAID0: fail: too many partial write",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			HALF_STRIPE_LEN, HALF_STRIPE_LEN, 0, 0,
		},
		.expected_result = -EIO,
	},
	/*
	 * Error case: Partial missing device is not allowed even on non-DEGRADED
	 * mount.
	 */
	{
		.description = "RAID0: fail: missing device on DEGRADED",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_MISSING_DEV,
		},
		.degraded = true,
		.expected_result = -EIO,
	},

	/*
	 * One sequential zone and one conventional zone, having matching
	 * last_alloc.
	 */
	{
		.description = "RAID0: seq zone and conv zone, partially written stripe",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_CONVENTIONAL,
		},
		.last_alloc = SZ_2M - SZ_4K,
		.expected_alloc_offset = SZ_2M - SZ_4K,
	},
	{
		.description = "RAID0: conv zone and seq zone, partially written stripe",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 2,
		.alloc_offsets = {
			WP_CONVENTIONAL, SZ_1M,
		},
		.last_alloc = SZ_2M + SZ_4K,
		.expected_alloc_offset = SZ_2M + SZ_4K,
	},
	/*
	 * Error case: one sequential and one conventional zone, but having larger
	 * last_alloc than write pointer.
	 */
	{
		.description = "RAID0: fail: seq zone and conv zone, larger last_alloc",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 2,
		.alloc_offsets = {
			SZ_1M, WP_CONVENTIONAL,
		},
		.last_alloc = SZ_2M + BTRFS_STRIPE_LEN * 2,
		.expected_result = -EIO,
	},

	/* RAID0, 4 stripes with seq zones and conv zones. */
	{
		.description = "RAID0: stripes [2, 2, ?, ?] last_alloc = 6",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN * 6,
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 6,
	},
	{
		.description = "RAID0: stripes [2, 2, ?, ?] last_alloc = 7.5",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN * 7 + HALF_STRIPE_LEN,
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 7 + HALF_STRIPE_LEN,
	},
	{
		.description = "RAID0: stripes [3, ?, ?, ?] last_alloc = 1",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 3, WP_CONVENTIONAL,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN,
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 9,
	},
	{
		.description = "RAID0: stripes [2, ?, 1, ?] last_alloc = 5",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, WP_CONVENTIONAL,
			BTRFS_STRIPE_LEN, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN * 5,
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 5,
	},
	{
		.description = "RAID0: fail: stripes [2, ?, 1, ?] last_alloc = 7",
		.raid_type = BTRFS_BLOCK_GROUP_RAID0,
		.num_stripes = 4,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, WP_CONVENTIONAL,
			BTRFS_STRIPE_LEN, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN * 7,
		.expected_result = -EIO,
	},

	/* RAID10 */
	/* Normal case */
	{
		.description = "RAID10: initial partial write",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 4,
		.alloc_offsets = {
			HALF_STRIPE_LEN, HALF_STRIPE_LEN, 0, 0,
		},
		.expected_alloc_offset = HALF_STRIPE_LEN,
	},
	{
		.description = "RAID10: while in second stripe",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			BTRFS_STRIPE_LEN + HALF_STRIPE_LEN,
			BTRFS_STRIPE_LEN + HALF_STRIPE_LEN,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
		},
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 5 + HALF_STRIPE_LEN,
	},
	{
		.description = "RAID10: one stripe advanced",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 4,
		.alloc_offsets = {
			SZ_1M + BTRFS_STRIPE_LEN, SZ_1M + BTRFS_STRIPE_LEN,
			SZ_1M, SZ_1M,
		},
		.expected_alloc_offset = SZ_2M + BTRFS_STRIPE_LEN,
	},
	{
		.description = "RAID10: one stripe advanced, with conventional zone",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 4,
		.alloc_offsets = {
			SZ_1M + BTRFS_STRIPE_LEN, WP_CONVENTIONAL,
			WP_CONVENTIONAL, SZ_1M,
		},
		.expected_alloc_offset = SZ_2M + BTRFS_STRIPE_LEN,
	},
	/* Error case: having different write pointers. */
	{
		.description = "RAID10: fail: disordered stripes",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
		},
		.expected_result = -EIO,
	},
	{
		.description = "RAID10: fail: far distance",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 3, BTRFS_STRIPE_LEN * 3,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
		},
		.expected_result = -EIO,
	},
	{
		.description = "RAID10: fail: too many partial write",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			HALF_STRIPE_LEN, HALF_STRIPE_LEN,
			HALF_STRIPE_LEN, HALF_STRIPE_LEN,
			0, 0, 0, 0,
		},
		.expected_result = -EIO,
	},
	/*
	 * Error case: Partial missing device in RAID0 level is not allowed even on
	 * non-DEGRADED mount.
	 */
	{
		.description = "RAID10: fail: missing device on DEGRADED",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 4,
		.alloc_offsets = {
			SZ_1M, SZ_1M,
			WP_MISSING_DEV, WP_MISSING_DEV,
		},
		.degraded = true,
		.expected_result = -EIO,
	},

	/*
	 * One sequential zone and one conventional zone, having matching
	 * last_alloc.
	 */
	{
		.description = "RAID10: seq zone and conv zone, partially written stripe",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 4,
		.alloc_offsets = {
			SZ_1M, SZ_1M,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = SZ_2M - SZ_4K,
		.expected_alloc_offset = SZ_2M - SZ_4K,
	},
	{
		.description = "RAID10: conv zone and seq zone, partially written stripe",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 4,
		.alloc_offsets = {
			WP_CONVENTIONAL, WP_CONVENTIONAL,
			SZ_1M, SZ_1M,
		},
		.last_alloc = SZ_2M + SZ_4K,
		.expected_alloc_offset = SZ_2M + SZ_4K,
	},
	/*
	 * Error case: one sequential and one conventional zone, but having larger
	 * last_alloc than write pointer.
	 */
	{
		.description = "RAID10: fail: seq zone and conv zone, larger last_alloc",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 4,
		.alloc_offsets = {
			SZ_1M, SZ_1M,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = SZ_2M + BTRFS_STRIPE_LEN * 2,
		.expected_result = -EIO,
	},

	/* RAID10, 4 stripes with seq zones and conv zones. */
	{
		.description = "RAID10: stripes [2, 2, ?, ?] last_alloc = 6",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN * 6,
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 6,
	},
	{
		.description = "RAID10: stripes [2, 2, ?, ?] last_alloc = 7.5",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN * 7 + HALF_STRIPE_LEN,
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 7 + HALF_STRIPE_LEN,
	},
	{
		.description = "RAID10: stripes [3, ?, ?, ?] last_alloc = 1",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 3, BTRFS_STRIPE_LEN * 3,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN,
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 9,
	},
	{
		.description = "RAID10: stripes [2, ?, 1, ?] last_alloc = 5",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN * 5,
		.expected_alloc_offset = BTRFS_STRIPE_LEN * 5,
	},
	{
		.description = "RAID10: fail: stripes [2, ?, 1, ?] last_alloc = 7",
		.raid_type = BTRFS_BLOCK_GROUP_RAID10,
		.num_stripes = 8,
		.alloc_offsets = {
			BTRFS_STRIPE_LEN * 2, BTRFS_STRIPE_LEN * 2,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
			BTRFS_STRIPE_LEN, BTRFS_STRIPE_LEN,
			WP_CONVENTIONAL, WP_CONVENTIONAL,
		},
		.last_alloc = BTRFS_STRIPE_LEN * 7,
		.expected_result = -EIO,
	},
};

int btrfs_test_zoned(void)
{
	struct btrfs_fs_info *fs_info __free(btrfs_free_dummy_fs_info) = NULL;
	int ret;

	test_msg("running zoned tests (error messages are expected)");

	fs_info = btrfs_alloc_dummy_fs_info(PAGE_SIZE, PAGE_SIZE);
	if (!fs_info) {
		test_std_err(TEST_ALLOC_FS_INFO);
		return -ENOMEM;
	}

	for (int i = 0; i < ARRAY_SIZE(load_zone_info_tests); i++) {
		ret = test_load_zone_info(fs_info, &load_zone_info_tests[i]);
		if (ret) {
			test_err("test case \"%s\" failed", load_zone_info_tests[i].description);
			return ret;
		}
	}

	return 0;
}