blk-integrity.h source code [linux/include/linux/blk-integrity.h]

1	/ SPDX-License-Identifier: GPL-2.0 /
2	#ifndef _LINUX_BLK_INTEGRITY_H
3	#define _LINUX_BLK_INTEGRITY_H
4
5	#include <linux/blk-mq.h>
6	#include <linux/bio-integrity.h>
7
8	struct request;
9
10	enum blk_integrity_flags {
11	BLK_INTEGRITY_NOVERIFY = `1` << `0`,
12	BLK_INTEGRITY_NOGENERATE = `1` << `1`,
13	BLK_INTEGRITY_DEVICE_CAPABLE = `1` << `2`,
14	BLK_INTEGRITY_REF_TAG = `1` << `3`,
15	BLK_INTEGRITY_STACKED = `1` << `4`,
16	};
17
18	const char blk_integrity_profile_name(struct* blk_integrity *bi);
19	bool queue_limits_stack_integrity(struct queue_limits *t,
20	struct queue_limits *b);
21	static inline bool queue_limits_stack_integrity_bdev(struct queue_limits *t,
22	struct block_device *bdev)
23	{
24	return queue_limits_stack_integrity(t, b: &bdev->bd_disk->queue->limits);
25	}
26
27	#ifdef CONFIG_BLK_DEV_INTEGRITY
28	int blk_rq_map_integrity_sg(struct request , struct* scatterlist *);
29	int blk_rq_count_integrity_sg(struct request_queue , struct* bio *);
30	int blk_rq_integrity_map_user(struct request rq, void* __user *ubuf,
31	ssize_t bytes);
32
33	static inline bool
34	blk_integrity_queue_supports_integrity(struct request_queue *q)
35	{
36	return q->limits.integrity.tuple_size;
37	}
38
39	static inline struct blk_integrity blk_get_integrity(struct* gendisk *disk)
40	{
41	if (!blk_integrity_queue_supports_integrity(q: disk->queue))
42	return NULL;
43	return &disk->queue->limits.integrity;
44	}
45
46	static inline struct blk_integrity *
47	bdev_get_integrity(struct block_device *bdev)
48	{
49	return blk_get_integrity(disk: bdev->bd_disk);
50	}
51
52	static inline unsigned short
53	queue_max_integrity_segments(const struct request_queue *q)
54	{
55	return q->limits.max_integrity_segments;
56	}
57
58	/**
59	* bio_integrity_intervals - Return number of integrity intervals for a bio
60	* @bi: blk_integrity profile for device
61	* @sectors: Size of the bio in 512-byte sectors
62	*
63	* Description: The block layer calculates everything in 512 byte
64	* sectors but integrity metadata is done in terms of the data integrity
65	* interval size of the storage device. Convert the block layer sectors
66	* to the appropriate number of integrity intervals.
67	*/
68	static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
69	unsigned int sectors)
70	{
71	return sectors >> (bi->interval_exp - `9`);
72	}
73
74	static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
75	unsigned int sectors)
76	{
77	return bio_integrity_intervals(bi, sectors) * bi->tuple_size;
78	}
79
80	static inline bool blk_integrity_rq(struct request *rq)
81	{
82	return rq->cmd_flags & REQ_INTEGRITY;
83	}
84
85	/*
86	* Return the current bvec that contains the integrity data. bip_iter may be
87	* advanced to iterate over the integrity data.
88	*/
89	static inline struct bio_vec rq_integrity_vec(struct request *rq)
90	{
91	return mp_bvec_iter_bvec(rq->bio->bi_integrity->bip_vec,
92	rq->bio->bi_integrity->bip_iter);
93	}
94	#else /* CONFIG_BLK_DEV_INTEGRITY */
95	static inline int blk_rq_count_integrity_sg(struct request_queue *q,
96	struct bio *b)
97	{
98	return `0`;
99	}
100	static inline int blk_rq_map_integrity_sg(struct request *q,
101	struct scatterlist *s)
102	{
103	return `0`;
104	}
105	static inline int blk_rq_integrity_map_user(struct request *rq,
106	void __user *ubuf,
107	ssize_t bytes)
108	{
109	return -EINVAL;
110	}
111	static inline struct blk_integrity bdev_get_integrity(struct* block_device *b)
112	{
113	return NULL;
114	}
115	static inline struct blk_integrity blk_get_integrity(struct* gendisk *disk)
116	{
117	return NULL;
118	}
119	static inline bool
120	blk_integrity_queue_supports_integrity(struct request_queue *q)
121	{
122	return false;
123	}
124	static inline unsigned short
125	queue_max_integrity_segments(const struct request_queue *q)
126	{
127	return `0`;
128	}
129
130	static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
131	unsigned int sectors)
132	{
133	return `0`;
134	}
135
136	static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
137	unsigned int sectors)
138	{
139	return `0`;
140	}
141	static inline int blk_integrity_rq(struct request *rq)
142	{
143	return `0`;
144	}
145
146	static inline struct bio_vec rq_integrity_vec(struct request *rq)
147	{
148	/ the optimizer will remove all calls to this function /
149	return (struct bio_vec){ };
150	}
151	#endif /* CONFIG_BLK_DEV_INTEGRITY */
152
153	#endif /* _LINUX_BLK_INTEGRITY_H */
154

source code of linux/include/linux/blk-integrity.h