[fio.git] / zbd.h

/*
 * Copyright (C) 2018 Western Digital Corporation or its affiliates.
 *
 * This file is released under the GPL.
 */

#ifndef FIO_ZBD_H
#define FIO_ZBD_H

#include <inttypes.h>
#include "fio.h"	/* FIO_MAX_OPEN_ZBD_ZONES */
#ifdef CONFIG_LINUX_BLKZONED
#include <linux/blkzoned.h>
#endif

struct fio_file;

/*
 * Zoned block device models.
 */
enum blk_zoned_model {
	ZBD_DM_NONE,	/* Regular block device */
	ZBD_DM_HOST_AWARE,	/* Host-aware zoned block device */
	ZBD_DM_HOST_MANAGED,	/* Host-managed zoned block device */
};

enum io_u_action {
	io_u_accept	= 0,
	io_u_eof	= 1,
};

/**
 * struct fio_zone_info - information about a single ZBD zone
 * @start: zone start in 512 byte units
 * @wp: zone write pointer location in 512 byte units
 * @verify_block: number of blocks that have been verified for this zone
 * @mutex: protects the modifiable members in this structure
 * @type: zone type (BLK_ZONE_TYPE_*)
 * @cond: zone state (BLK_ZONE_COND_*)
 * @open: whether or not this zone is currently open. Only relevant if
 *		max_open_zones > 0.
 * @reset_zone: whether or not this zone should be reset before writing to it
 */
struct fio_zone_info {
#ifdef CONFIG_LINUX_BLKZONED
	pthread_mutex_t		mutex;
	uint64_t		start;
	uint64_t		wp;
	uint32_t		verify_block;
	enum blk_zone_type	type:2;
	enum blk_zone_cond	cond:4;
	unsigned int		open:1;
	unsigned int		reset_zone:1;
#endif
};

/**
 * zoned_block_device_info - zoned block device characteristics
 * @model: Device model.
 * @mutex: Protects the modifiable members in this structure (refcount and
 *		num_open_zones).
 * @zone_size: size of a single zone in units of 512 bytes
 * @zone_size_log2: log2 of the zone size in bytes if it is a power of 2 or 0
 *		if the zone size is not a power of 2.
 * @nr_zones: number of zones
 * @refcount: number of fio files that share this structure
 * @num_open_zones: number of open zones
 * @open_zones: zone numbers of open zones
 * @zone_info: description of the individual zones
 *
 * Only devices for which all zones have the same size are supported.
 * Note: if the capacity is not a multiple of the zone size then the last zone
 * will be smaller than 'zone_size'.
 */
struct zoned_block_device_info {
	enum blk_zoned_model	model;
	pthread_mutex_t		mutex;
	uint64_t		zone_size;
	uint32_t		zone_size_log2;
	uint32_t		nr_zones;
	uint32_t		refcount;
	uint32_t		num_open_zones;
	uint32_t		open_zones[FIO_MAX_OPEN_ZBD_ZONES];
	struct fio_zone_info	zone_info[0];
};

#ifdef CONFIG_LINUX_BLKZONED
void zbd_free_zone_info(struct fio_file *f);
int zbd_init(struct thread_data *td);
void zbd_file_reset(struct thread_data *td, struct fio_file *f);
bool zbd_unaligned_write(int error_code);
enum io_u_action zbd_adjust_block(struct thread_data *td, struct io_u *io_u);
int zbd_do_trim(struct thread_data *td, const struct io_u *io_u);
void zbd_update_wp(struct thread_data *td, const struct io_u *io_u);
char *zbd_write_status(const struct thread_stat *ts);
#else
static inline void zbd_free_zone_info(struct fio_file *f)
{
}

static inline int zbd_init(struct thread_data *td)
{
	return 0;
}

static inline void zbd_file_reset(struct thread_data *td, struct fio_file *f)
{
}

static inline bool zbd_unaligned_write(int error_code)
{
	return false;
}

static inline enum io_u_action zbd_adjust_block(struct thread_data *td,
						struct io_u *io_u)
{
	return io_u_accept;
}

static inline int zbd_do_trim(struct thread_data *td, const struct io_u *io_u)
{
	return 1;
}

static inline void zbd_update_wp(struct thread_data *td,
				 const struct io_u *io_u)
{
}

static inline char *zbd_write_status(const struct thread_stat *ts)
{
	return NULL;
}
#endif

#endif /* FIO_ZBD_H */
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2018 Western Digital Corporation or its affiliates.
	3	*
	4	* This file is released under the GPL.
	5	*/
	6
	7	#ifndef FIO_ZBD_H
	8	#define FIO_ZBD_H
	9
	10	#include <inttypes.h>
	11	#include "fio.h" /* FIO_MAX_OPEN_ZBD_ZONES */
	12	#ifdef CONFIG_LINUX_BLKZONED
	13	#include <linux/blkzoned.h>
	14	#endif
	15
	16	struct fio_file;
	17
	18	/*
	19	* Zoned block device models.
	20	*/
	21	enum blk_zoned_model {
	22	ZBD_DM_NONE, /* Regular block device */
	23	ZBD_DM_HOST_AWARE, /* Host-aware zoned block device */
	24	ZBD_DM_HOST_MANAGED, /* Host-managed zoned block device */
	25	};
	26
	27	enum io_u_action {
	28	io_u_accept = 0,
	29	io_u_eof = 1,
	30	};
	31
	32	/**
	33	* struct fio_zone_info - information about a single ZBD zone
	34	* @start: zone start in 512 byte units
	35	* @wp: zone write pointer location in 512 byte units
	36	* @verify_block: number of blocks that have been verified for this zone
	37	* @mutex: protects the modifiable members in this structure
	38	* @type: zone type (BLK_ZONE_TYPE_*)
	39	* @cond: zone state (BLK_ZONE_COND_*)
	40	* @open: whether or not this zone is currently open. Only relevant if
	41	* max_open_zones > 0.
	42	* @reset_zone: whether or not this zone should be reset before writing to it
	43	*/
	44	struct fio_zone_info {
	45	#ifdef CONFIG_LINUX_BLKZONED
	46	pthread_mutex_t mutex;
	47	uint64_t start;
	48	uint64_t wp;
	49	uint32_t verify_block;
	50	enum blk_zone_type type:2;
	51	enum blk_zone_cond cond:4;
	52	unsigned int open:1;
	53	unsigned int reset_zone:1;
	54	#endif
	55	};
	56
	57	/**
	58	* zoned_block_device_info - zoned block device characteristics
	59	* @model: Device model.
	60	* @mutex: Protects the modifiable members in this structure (refcount and
	61	* num_open_zones).
	62	* @zone_size: size of a single zone in units of 512 bytes
	63	* @zone_size_log2: log2 of the zone size in bytes if it is a power of 2 or 0
	64	* if the zone size is not a power of 2.
	65	* @nr_zones: number of zones
	66	* @refcount: number of fio files that share this structure
	67	* @num_open_zones: number of open zones
	68	* @open_zones: zone numbers of open zones
	69	* @zone_info: description of the individual zones
	70	*
	71	* Only devices for which all zones have the same size are supported.
	72	* Note: if the capacity is not a multiple of the zone size then the last zone
	73	* will be smaller than 'zone_size'.
	74	*/
	75	struct zoned_block_device_info {
	76	enum blk_zoned_model model;
	77	pthread_mutex_t mutex;
	78	uint64_t zone_size;
	79	uint32_t zone_size_log2;
	80	uint32_t nr_zones;
	81	uint32_t refcount;
	82	uint32_t num_open_zones;
	83	uint32_t open_zones[FIO_MAX_OPEN_ZBD_ZONES];
	84	struct fio_zone_info zone_info[0];
	85	};
	86
	87	#ifdef CONFIG_LINUX_BLKZONED
	88	void zbd_free_zone_info(struct fio_file *f);
	89	int zbd_init(struct thread_data *td);
	90	void zbd_file_reset(struct thread_data td, struct fio_file f);
	91	bool zbd_unaligned_write(int error_code);
	92	enum io_u_action zbd_adjust_block(struct thread_data td, struct io_u io_u);
	93	int zbd_do_trim(struct thread_data td, const struct io_u io_u);
	94	void zbd_update_wp(struct thread_data td, const struct io_u io_u);
	95	char zbd_write_status(const struct thread_stat ts);
	96	#else
	97	static inline void zbd_free_zone_info(struct fio_file *f)
	98	{
	99	}
	100
	101	static inline int zbd_init(struct thread_data *td)
	102	{
	103	return 0;
	104	}
	105
	106	static inline void zbd_file_reset(struct thread_data td, struct fio_file f)
	107	{
	108	}
	109
	110	static inline bool zbd_unaligned_write(int error_code)
	111	{
	112	return false;
	113	}
	114
	115	static inline enum io_u_action zbd_adjust_block(struct thread_data *td,
	116	struct io_u *io_u)
	117	{
	118	return io_u_accept;
	119	}
	120
	121	static inline int zbd_do_trim(struct thread_data td, const struct io_u io_u)
	122	{
	123	return 1;
	124	}
	125
	126	static inline void zbd_update_wp(struct thread_data *td,
	127	const struct io_u *io_u)
	128	{
	129	}
	130
	131	static inline char zbd_write_status(const struct thread_stat ts)
	132	{
	133	return NULL;
	134	}
	135	#endif
	136
	137	#endif /* FIO_ZBD_H */