[linux-block.git] / fs / btrfs / zoned.h

/* SPDX-License-Identifier: GPL-2.0 */

#ifndef BTRFS_ZONED_H
#define BTRFS_ZONED_H

#include <linux/types.h>
#include <linux/blkdev.h>
#include "volumes.h"
#include "disk-io.h"

struct btrfs_zoned_device_info {
	/*
	 * Number of zones, zone size and types of zones if bdev is a
	 * zoned block device.
	 */
	u64 zone_size;
	u8  zone_size_shift;
	u64 max_zone_append_size;
	u32 nr_zones;
	unsigned long *seq_zones;
	unsigned long *empty_zones;
	struct blk_zone sb_zones[2 * BTRFS_SUPER_MIRROR_MAX];
};

#ifdef CONFIG_BLK_DEV_ZONED
int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos,
		       struct blk_zone *zone);
int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info);
int btrfs_get_dev_zone_info(struct btrfs_device *device);
void btrfs_destroy_dev_zone_info(struct btrfs_device *device);
int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info);
int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info);
int btrfs_sb_log_location_bdev(struct block_device *bdev, int mirror, int rw,
			       u64 *bytenr_ret);
int btrfs_sb_log_location(struct btrfs_device *device, int mirror, int rw,
			  u64 *bytenr_ret);
void btrfs_advance_sb_log(struct btrfs_device *device, int mirror);
int btrfs_reset_sb_log_zones(struct block_device *bdev, int mirror);
#else /* CONFIG_BLK_DEV_ZONED */
static inline int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos,
				     struct blk_zone *zone)
{
	return 0;
}

static inline int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info)
{
	return 0;
}

static inline int btrfs_get_dev_zone_info(struct btrfs_device *device)
{
	return 0;
}

static inline void btrfs_destroy_dev_zone_info(struct btrfs_device *device) { }

static inline int btrfs_check_zoned_mode(const struct btrfs_fs_info *fs_info)
{
	if (!btrfs_is_zoned(fs_info))
		return 0;

	btrfs_err(fs_info, "zoned block devices support is not enabled");
	return -EOPNOTSUPP;
}

static inline int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info)
{
	return 0;
}

static inline int btrfs_sb_log_location_bdev(struct block_device *bdev,
					     int mirror, int rw, u64 *bytenr_ret)
{
	*bytenr_ret = btrfs_sb_offset(mirror);
	return 0;
}

static inline int btrfs_sb_log_location(struct btrfs_device *device, int mirror,
					int rw, u64 *bytenr_ret)
{
	*bytenr_ret = btrfs_sb_offset(mirror);
	return 0;
}

static inline void btrfs_advance_sb_log(struct btrfs_device *device, int mirror)
{ }

static inline int btrfs_reset_sb_log_zones(struct block_device *bdev, int mirror)
{
	return 0;
}

#endif

static inline bool btrfs_dev_is_sequential(struct btrfs_device *device, u64 pos)
{
	struct btrfs_zoned_device_info *zone_info = device->zone_info;

	if (!zone_info)
		return false;

	return test_bit(pos >> zone_info->zone_size_shift, zone_info->seq_zones);
}

static inline bool btrfs_dev_is_empty_zone(struct btrfs_device *device, u64 pos)
{
	struct btrfs_zoned_device_info *zone_info = device->zone_info;

	if (!zone_info)
		return true;

	return test_bit(pos >> zone_info->zone_size_shift, zone_info->empty_zones);
}

static inline void btrfs_dev_set_empty_zone_bit(struct btrfs_device *device,
						u64 pos, bool set)
{
	struct btrfs_zoned_device_info *zone_info = device->zone_info;
	unsigned int zno;

	if (!zone_info)
		return;

	zno = pos >> zone_info->zone_size_shift;
	if (set)
		set_bit(zno, zone_info->empty_zones);
	else
		clear_bit(zno, zone_info->empty_zones);
}

static inline void btrfs_dev_set_zone_empty(struct btrfs_device *device, u64 pos)
{
	btrfs_dev_set_empty_zone_bit(device, pos, true);
}

static inline void btrfs_dev_clear_zone_empty(struct btrfs_device *device, u64 pos)
{
	btrfs_dev_set_empty_zone_bit(device, pos, false);
}

static inline bool btrfs_check_device_zone_type(const struct btrfs_fs_info *fs_info,
						struct block_device *bdev)
{
	u64 zone_size;

	if (btrfs_is_zoned(fs_info)) {
		zone_size = bdev_zone_sectors(bdev) << SECTOR_SHIFT;
		/* Do not allow non-zoned device */
		return bdev_is_zoned(bdev) && fs_info->zone_size == zone_size;
	}

	/* Do not allow Host Manged zoned device */
	return bdev_zoned_model(bdev) != BLK_ZONED_HM;
}

static inline bool btrfs_check_super_location(struct btrfs_device *device, u64 pos)
{
	/*
	 * On a non-zoned device, any address is OK. On a zoned device,
	 * non-SEQUENTIAL WRITE REQUIRED zones are capable.
	 */
	return device->zone_info == NULL || !btrfs_dev_is_sequential(device, pos);
}

#endif
Commit	Line	Data
5b316468 NA	1	/* SPDX-License-Identifier: GPL-2.0 */
	2
	3	#ifndef BTRFS_ZONED_H
	4	#define BTRFS_ZONED_H
	5
	6	#include <linux/types.h>
b70f5097	7	#include <linux/blkdev.h>
12659251 NA	8	#include "volumes.h"
12659251 NA	9	#include "disk-io.h"
5b316468 NA	10
	11	struct btrfs_zoned_device_info {
	12	/*
	13	* Number of zones, zone size and types of zones if bdev is a
	14	* zoned block device.
	15	*/
	16	u64 zone_size;
	17	u8 zone_size_shift;
862931c7	18	u64 max_zone_append_size;
5b316468 NA	19	u32 nr_zones;
	20	unsigned long *seq_zones;
	21	unsigned long *empty_zones;
12659251	22	struct blk_zone sb_zones[2 * BTRFS_SUPER_MIRROR_MAX];
5b316468 NA	23	};
	24
	25	#ifdef CONFIG_BLK_DEV_ZONED
	26	int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos,
	27	struct blk_zone *zone);
73651042	28	int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info);
5b316468 NA	29	int btrfs_get_dev_zone_info(struct btrfs_device *device);
5b316468 NA	30	void btrfs_destroy_dev_zone_info(struct btrfs_device *device);
b70f5097	31	int btrfs_check_zoned_mode(struct btrfs_fs_info *fs_info);
5d1ab66c	32	int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info);
12659251 NA	33	int btrfs_sb_log_location_bdev(struct block_device *bdev, int mirror, int rw,
	34	u64 *bytenr_ret);
	35	int btrfs_sb_log_location(struct btrfs_device *device, int mirror, int rw,
	36	u64 *bytenr_ret);
	37	void btrfs_advance_sb_log(struct btrfs_device *device, int mirror);
	38	int btrfs_reset_sb_log_zones(struct block_device *bdev, int mirror);
5b316468 NA	39	#else /* CONFIG_BLK_DEV_ZONED */
	40	static inline int btrfs_get_dev_zone(struct btrfs_device *device, u64 pos,
	41	struct blk_zone *zone)
	42	{
	43	return 0;
	44	}
	45
73651042 NA	46	static inline int btrfs_get_dev_zone_info_all_devices(struct btrfs_fs_info *fs_info)
	47	{
	48	return 0;
	49	}
	50
5b316468 NA	51	static inline int btrfs_get_dev_zone_info(struct btrfs_device *device)
	52	{
	53	return 0;
	54	}
	55
	56	static inline void btrfs_destroy_dev_zone_info(struct btrfs_device *device) { }
	57
b70f5097 NA	58	static inline int btrfs_check_zoned_mode(const struct btrfs_fs_info *fs_info)
	59	{
	60	if (!btrfs_is_zoned(fs_info))
	61	return 0;
	62
	63	btrfs_err(fs_info, "zoned block devices support is not enabled");
	64	return -EOPNOTSUPP;
	65	}
	66
5d1ab66c NA	67	static inline int btrfs_check_mountopts_zoned(struct btrfs_fs_info *info)
	68	{
	69	return 0;
	70	}
	71
12659251 NA	72	static inline int btrfs_sb_log_location_bdev(struct block_device *bdev,
	73	int mirror, int rw, u64 *bytenr_ret)
	74	{
	75	*bytenr_ret = btrfs_sb_offset(mirror);
	76	return 0;
	77	}
	78
	79	static inline int btrfs_sb_log_location(struct btrfs_device *device, int mirror,
	80	int rw, u64 *bytenr_ret)
	81	{
	82	*bytenr_ret = btrfs_sb_offset(mirror);
	83	return 0;
	84	}
	85
	86	static inline void btrfs_advance_sb_log(struct btrfs_device *device, int mirror)
	87	{ }
	88
	89	static inline int btrfs_reset_sb_log_zones(struct block_device *bdev, int mirror)
	90	{
	91	return 0;
	92	}
	93
5b316468 NA	94	#endif
	95
	96	static inline bool btrfs_dev_is_sequential(struct btrfs_device *device, u64 pos)
	97	{
	98	struct btrfs_zoned_device_info *zone_info = device->zone_info;
	99
	100	if (!zone_info)
	101	return false;
	102
	103	return test_bit(pos >> zone_info->zone_size_shift, zone_info->seq_zones);
	104	}
	105
	106	static inline bool btrfs_dev_is_empty_zone(struct btrfs_device *device, u64 pos)
	107	{
	108	struct btrfs_zoned_device_info *zone_info = device->zone_info;
	109
	110	if (!zone_info)
	111	return true;
	112
	113	return test_bit(pos >> zone_info->zone_size_shift, zone_info->empty_zones);
	114	}
	115
	116	static inline void btrfs_dev_set_empty_zone_bit(struct btrfs_device *device,
	117	u64 pos, bool set)
	118	{
	119	struct btrfs_zoned_device_info *zone_info = device->zone_info;
	120	unsigned int zno;
	121
	122	if (!zone_info)
	123	return;
	124
	125	zno = pos >> zone_info->zone_size_shift;
	126	if (set)
	127	set_bit(zno, zone_info->empty_zones);
	128	else
	129	clear_bit(zno, zone_info->empty_zones);
	130	}
	131
	132	static inline void btrfs_dev_set_zone_empty(struct btrfs_device *device, u64 pos)
	133	{
	134	btrfs_dev_set_empty_zone_bit(device, pos, true);
	135	}
	136
	137	static inline void btrfs_dev_clear_zone_empty(struct btrfs_device *device, u64 pos)
	138	{
	139	btrfs_dev_set_empty_zone_bit(device, pos, false);
	140	}
	141
b70f5097 NA	142	static inline bool btrfs_check_device_zone_type(const struct btrfs_fs_info *fs_info,
	143	struct block_device *bdev)
	144	{
	145	u64 zone_size;
	146
	147	if (btrfs_is_zoned(fs_info)) {
	148	zone_size = bdev_zone_sectors(bdev) << SECTOR_SHIFT;
	149	/* Do not allow non-zoned device */
	150	return bdev_is_zoned(bdev) && fs_info->zone_size == zone_size;
	151	}
	152
	153	/* Do not allow Host Manged zoned device */
	154	return bdev_zoned_model(bdev) != BLK_ZONED_HM;
	155	}
	156
12659251 NA	157	static inline bool btrfs_check_super_location(struct btrfs_device *device, u64 pos)
	158	{
	159	/*
	160	* On a non-zoned device, any address is OK. On a zoned device,
	161	* non-SEQUENTIAL WRITE REQUIRED zones are capable.
	162	*/
	163	return device->zone_info == NULL \|\| !btrfs_dev_is_sequential(device, pos);
	164	}
	165
5b316468	166	#endif