1
2
3
4
5
6#ifndef __LINUX_BLK_TYPES_H
7#define __LINUX_BLK_TYPES_H
8
9#include <linux/types.h>
10#include <linux/bvec.h>
11
12struct bio_set;
13struct bio;
14struct bio_integrity_payload;
15struct page;
16struct block_device;
17struct io_context;
18struct cgroup_subsys_state;
19typedef void (bio_end_io_t) (struct bio *);
20
21
22
23
24typedef u8 __bitwise blk_status_t;
25#define BLK_STS_OK 0
26#define BLK_STS_NOTSUPP ((__force blk_status_t)1)
27#define BLK_STS_TIMEOUT ((__force blk_status_t)2)
28#define BLK_STS_NOSPC ((__force blk_status_t)3)
29#define BLK_STS_TRANSPORT ((__force blk_status_t)4)
30#define BLK_STS_TARGET ((__force blk_status_t)5)
31#define BLK_STS_NEXUS ((__force blk_status_t)6)
32#define BLK_STS_MEDIUM ((__force blk_status_t)7)
33#define BLK_STS_PROTECTION ((__force blk_status_t)8)
34#define BLK_STS_RESOURCE ((__force blk_status_t)9)
35#define BLK_STS_IOERR ((__force blk_status_t)10)
36
37
38#define BLK_STS_DM_REQUEUE ((__force blk_status_t)11)
39
40#define BLK_STS_AGAIN ((__force blk_status_t)12)
41
42struct blk_issue_stat {
43 u64 stat;
44};
45
46
47
48
49
50struct bio {
51 struct bio *bi_next;
52 struct gendisk *bi_disk;
53 u8 bi_partno;
54 blk_status_t bi_status;
55 unsigned int bi_opf;
56
57
58
59 unsigned short bi_flags;
60 unsigned short bi_ioprio;
61 unsigned short bi_write_hint;
62
63 struct bvec_iter bi_iter;
64
65
66
67
68 unsigned int bi_phys_segments;
69
70
71
72
73
74 unsigned int bi_seg_front_size;
75 unsigned int bi_seg_back_size;
76
77 atomic_t __bi_remaining;
78
79 bio_end_io_t *bi_end_io;
80
81 void *bi_private;
82#ifdef CONFIG_BLK_CGROUP
83
84
85
86
87 struct io_context *bi_ioc;
88 struct cgroup_subsys_state *bi_css;
89#ifdef CONFIG_BLK_DEV_THROTTLING_LOW
90 void *bi_cg_private;
91 struct blk_issue_stat bi_issue_stat;
92#endif
93#endif
94 union {
95#if defined(CONFIG_BLK_DEV_INTEGRITY)
96 struct bio_integrity_payload *bi_integrity;
97#endif
98 };
99
100 unsigned short bi_vcnt;
101
102
103
104
105
106 unsigned short bi_max_vecs;
107
108 atomic_t __bi_cnt;
109
110 struct bio_vec *bi_io_vec;
111
112 struct bio_set *bi_pool;
113
114
115
116
117
118
119 struct bio_vec bi_inline_vecs[0];
120};
121
122#define BIO_RESET_BYTES offsetof(struct bio, bi_max_vecs)
123
124
125
126
127#define BIO_SEG_VALID 1
128#define BIO_CLONED 2
129#define BIO_BOUNCED 3
130#define BIO_USER_MAPPED 4
131#define BIO_NULL_MAPPED 5
132#define BIO_QUIET 6
133#define BIO_CHAIN 7
134#define BIO_REFFED 8
135#define BIO_THROTTLED 9
136
137#define BIO_TRACE_COMPLETION 10
138
139
140
141
142
143
144
145#define BVEC_POOL_NR 6
146#define BVEC_POOL_MAX (BVEC_POOL_NR - 1)
147
148
149
150
151
152
153#define BVEC_POOL_BITS (3)
154#define BVEC_POOL_OFFSET (16 - BVEC_POOL_BITS)
155#define BVEC_POOL_IDX(bio) ((bio)->bi_flags >> BVEC_POOL_OFFSET)
156#if (1<< BVEC_POOL_BITS) < (BVEC_POOL_NR+1)
157# error "BVEC_POOL_BITS is too small"
158#endif
159
160
161
162
163
164#define BIO_RESET_BITS BVEC_POOL_OFFSET
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179#define REQ_OP_BITS 8
180#define REQ_OP_MASK ((1 << REQ_OP_BITS) - 1)
181#define REQ_FLAG_BITS 24
182
183enum req_opf {
184
185 REQ_OP_READ = 0,
186
187 REQ_OP_WRITE = 1,
188
189 REQ_OP_FLUSH = 2,
190
191 REQ_OP_DISCARD = 3,
192
193 REQ_OP_ZONE_REPORT = 4,
194
195 REQ_OP_SECURE_ERASE = 5,
196
197 REQ_OP_ZONE_RESET = 6,
198
199 REQ_OP_WRITE_SAME = 7,
200
201 REQ_OP_WRITE_ZEROES = 9,
202
203
204 REQ_OP_SCSI_IN = 32,
205 REQ_OP_SCSI_OUT = 33,
206
207 REQ_OP_DRV_IN = 34,
208 REQ_OP_DRV_OUT = 35,
209
210 REQ_OP_LAST,
211};
212
213enum req_flag_bits {
214 __REQ_FAILFAST_DEV =
215 REQ_OP_BITS,
216 __REQ_FAILFAST_TRANSPORT,
217 __REQ_FAILFAST_DRIVER,
218 __REQ_SYNC,
219 __REQ_META,
220 __REQ_PRIO,
221 __REQ_NOMERGE,
222 __REQ_IDLE,
223 __REQ_INTEGRITY,
224 __REQ_FUA,
225 __REQ_PREFLUSH,
226 __REQ_RAHEAD,
227 __REQ_BACKGROUND,
228
229
230 __REQ_NOUNMAP,
231
232 __REQ_NOWAIT,
233 __REQ_NR_BITS,
234};
235
236#define REQ_FAILFAST_DEV (1ULL << __REQ_FAILFAST_DEV)
237#define REQ_FAILFAST_TRANSPORT (1ULL << __REQ_FAILFAST_TRANSPORT)
238#define REQ_FAILFAST_DRIVER (1ULL << __REQ_FAILFAST_DRIVER)
239#define REQ_SYNC (1ULL << __REQ_SYNC)
240#define REQ_META (1ULL << __REQ_META)
241#define REQ_PRIO (1ULL << __REQ_PRIO)
242#define REQ_NOMERGE (1ULL << __REQ_NOMERGE)
243#define REQ_IDLE (1ULL << __REQ_IDLE)
244#define REQ_INTEGRITY (1ULL << __REQ_INTEGRITY)
245#define REQ_FUA (1ULL << __REQ_FUA)
246#define REQ_PREFLUSH (1ULL << __REQ_PREFLUSH)
247#define REQ_RAHEAD (1ULL << __REQ_RAHEAD)
248#define REQ_BACKGROUND (1ULL << __REQ_BACKGROUND)
249
250#define REQ_NOUNMAP (1ULL << __REQ_NOUNMAP)
251#define REQ_NOWAIT (1ULL << __REQ_NOWAIT)
252
253#define REQ_FAILFAST_MASK \
254 (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
255
256#define REQ_NOMERGE_FLAGS \
257 (REQ_NOMERGE | REQ_PREFLUSH | REQ_FUA)
258
259#define bio_op(bio) \
260 ((bio)->bi_opf & REQ_OP_MASK)
261#define req_op(req) \
262 ((req)->cmd_flags & REQ_OP_MASK)
263
264
265static inline void bio_set_op_attrs(struct bio *bio, unsigned op,
266 unsigned op_flags)
267{
268 bio->bi_opf = op | op_flags;
269}
270
271static inline bool op_is_write(unsigned int op)
272{
273 return (op & 1);
274}
275
276
277
278
279
280static inline bool op_is_flush(unsigned int op)
281{
282 return op & (REQ_FUA | REQ_PREFLUSH);
283}
284
285
286
287
288
289
290static inline bool op_is_sync(unsigned int op)
291{
292 return (op & REQ_OP_MASK) == REQ_OP_READ ||
293 (op & (REQ_SYNC | REQ_FUA | REQ_PREFLUSH));
294}
295
296typedef unsigned int blk_qc_t;
297#define BLK_QC_T_NONE -1U
298#define BLK_QC_T_SHIFT 16
299#define BLK_QC_T_INTERNAL (1U << 31)
300
301static inline bool blk_qc_t_valid(blk_qc_t cookie)
302{
303 return cookie != BLK_QC_T_NONE;
304}
305
306static inline blk_qc_t blk_tag_to_qc_t(unsigned int tag, unsigned int queue_num,
307 bool internal)
308{
309 blk_qc_t ret = tag | (queue_num << BLK_QC_T_SHIFT);
310
311 if (internal)
312 ret |= BLK_QC_T_INTERNAL;
313
314 return ret;
315}
316
317static inline unsigned int blk_qc_t_to_queue_num(blk_qc_t cookie)
318{
319 return (cookie & ~BLK_QC_T_INTERNAL) >> BLK_QC_T_SHIFT;
320}
321
322static inline unsigned int blk_qc_t_to_tag(blk_qc_t cookie)
323{
324 return cookie & ((1u << BLK_QC_T_SHIFT) - 1);
325}
326
327static inline bool blk_qc_t_is_internal(blk_qc_t cookie)
328{
329 return (cookie & BLK_QC_T_INTERNAL) != 0;
330}
331
332struct blk_rq_stat {
333 s64 mean;
334 u64 min;
335 u64 max;
336 s32 nr_samples;
337 s32 nr_batch;
338 u64 batch;
339};
340
341#endif
342