blob: b3b5f5a89a9c6160f9f618f913fc22005b63eee4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Tejun Heo7cc01582010-08-03 13:14:58 +020010 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public Licens
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
17 */
18#ifndef __LINUX_BIO_H
19#define __LINUX_BIO_H
20
21#include <linux/highmem.h>
22#include <linux/mempool.h>
Jens Axboe22e2c502005-06-27 10:55:12 +020023#include <linux/ioprio.h>
Paul Gortmaker187f1882011-11-23 20:12:59 -050024#include <linux/bug.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
David Howells02a5e0a2007-08-11 22:34:32 +020026#ifdef CONFIG_BLOCK
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <asm/io.h>
29
Tejun Heo7cc01582010-08-03 13:14:58 +020030/* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
31#include <linux/blk_types.h>
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#define BIO_DEBUG
34
35#ifdef BIO_DEBUG
36#define BIO_BUG_ON BUG_ON
37#else
38#define BIO_BUG_ON
39#endif
40
Alexey Dobriyand84a8472006-06-25 05:49:32 -070041#define BIO_MAX_PAGES 256
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Mike Christie43b62ce2016-06-05 14:32:20 -050043#define bio_prio(bio) (bio)->bi_ioprio
44#define bio_set_prio(bio, prio) ((bio)->bi_ioprio = prio)
Jens Axboe22e2c502005-06-27 10:55:12 +020045
Kent Overstreet4550dd62013-08-07 14:26:21 -070046#define bio_iter_iovec(bio, iter) \
47 bvec_iter_bvec((bio)->bi_io_vec, (iter))
48
49#define bio_iter_page(bio, iter) \
50 bvec_iter_page((bio)->bi_io_vec, (iter))
51#define bio_iter_len(bio, iter) \
52 bvec_iter_len((bio)->bi_io_vec, (iter))
53#define bio_iter_offset(bio, iter) \
54 bvec_iter_offset((bio)->bi_io_vec, (iter))
55
56#define bio_page(bio) bio_iter_page((bio), (bio)->bi_iter)
57#define bio_offset(bio) bio_iter_offset((bio), (bio)->bi_iter)
58#define bio_iovec(bio) bio_iter_iovec((bio), (bio)->bi_iter)
Kent Overstreet79886132013-11-23 17:19:00 -080059
Kent Overstreet458b76e2013-09-24 16:26:05 -070060#define bio_multiple_segments(bio) \
61 ((bio)->bi_iter.bi_size != bio_iovec(bio).bv_len)
Kent Overstreet4f024f32013-10-11 15:44:27 -070062#define bio_sectors(bio) ((bio)->bi_iter.bi_size >> 9)
63#define bio_end_sector(bio) ((bio)->bi_iter.bi_sector + bio_sectors((bio)))
Jens Axboebf2de6f2007-09-27 13:01:25 +020064
Kent Overstreet458b76e2013-09-24 16:26:05 -070065/*
Christoph Hellwigd3849952016-11-01 07:40:11 -060066 * Return the data direction, READ or WRITE.
67 */
68#define bio_data_dir(bio) \
69 (op_is_write(bio_op(bio)) ? WRITE : READ)
70
71/*
Kent Overstreet458b76e2013-09-24 16:26:05 -070072 * Check whether this bio carries any data or not. A NULL bio is allowed.
73 */
74static inline bool bio_has_data(struct bio *bio)
75{
76 if (bio &&
77 bio->bi_iter.bi_size &&
Adrian Hunter7afafc82016-08-16 10:59:35 +030078 bio_op(bio) != REQ_OP_DISCARD &&
Chaitanya Kulkarnia6f07882016-11-30 12:28:59 -080079 bio_op(bio) != REQ_OP_SECURE_ERASE &&
80 bio_op(bio) != REQ_OP_WRITE_ZEROES)
Kent Overstreet458b76e2013-09-24 16:26:05 -070081 return true;
82
83 return false;
84}
85
Mike Christie95fe6c12016-06-05 14:31:48 -050086static inline bool bio_no_advance_iter(struct bio *bio)
87{
Adrian Hunter7afafc82016-08-16 10:59:35 +030088 return bio_op(bio) == REQ_OP_DISCARD ||
89 bio_op(bio) == REQ_OP_SECURE_ERASE ||
Chaitanya Kulkarnia6f07882016-11-30 12:28:59 -080090 bio_op(bio) == REQ_OP_WRITE_SAME ||
91 bio_op(bio) == REQ_OP_WRITE_ZEROES;
Mike Christie95fe6c12016-06-05 14:31:48 -050092}
93
Kent Overstreet458b76e2013-09-24 16:26:05 -070094static inline bool bio_mergeable(struct bio *bio)
95{
Jens Axboe1eff9d32016-08-05 15:35:16 -060096 if (bio->bi_opf & REQ_NOMERGE_FLAGS)
Kent Overstreet458b76e2013-09-24 16:26:05 -070097 return false;
98
99 return true;
100}
101
Tejun Heo2e46e8b2009-05-07 22:24:41 +0900102static inline unsigned int bio_cur_bytes(struct bio *bio)
Jens Axboebf2de6f2007-09-27 13:01:25 +0200103{
Kent Overstreet458b76e2013-09-24 16:26:05 -0700104 if (bio_has_data(bio))
Kent Overstreeta4ad39b12013-08-07 14:24:32 -0700105 return bio_iovec(bio).bv_len;
David Woodhousefb2dce82008-08-05 18:01:53 +0100106 else /* dataless requests such as discard */
Kent Overstreet4f024f32013-10-11 15:44:27 -0700107 return bio->bi_iter.bi_size;
Jens Axboebf2de6f2007-09-27 13:01:25 +0200108}
109
110static inline void *bio_data(struct bio *bio)
111{
Kent Overstreet458b76e2013-09-24 16:26:05 -0700112 if (bio_has_data(bio))
Jens Axboebf2de6f2007-09-27 13:01:25 +0200113 return page_address(bio_page(bio)) + bio_offset(bio);
114
115 return NULL;
116}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118/*
119 * will die
120 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121#define bvec_to_phys(bv) (page_to_phys((bv)->bv_page) + (unsigned long) (bv)->bv_offset)
122
123/*
124 * queues that have highmem support enabled may still need to revert to
125 * PIO transfers occasionally and thus map high pages temporarily. For
126 * permanent PIO fall back, user is probably better off disabling highmem
127 * I/O completely on that queue (see ide-dma for example)
128 */
Kent Overstreetf619d252013-08-07 14:30:33 -0700129#define __bio_kmap_atomic(bio, iter) \
130 (kmap_atomic(bio_iter_iovec((bio), (iter)).bv_page) + \
131 bio_iter_iovec((bio), (iter)).bv_offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Kent Overstreetf619d252013-08-07 14:30:33 -0700133#define __bio_kunmap_atomic(addr) kunmap_atomic(addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
135/*
136 * merge helpers etc
137 */
138
Jeremy Fitzhardingef92131c2008-10-29 14:10:51 +0100139/* Default implementation of BIOVEC_PHYS_MERGEABLE */
140#define __BIOVEC_PHYS_MERGEABLE(vec1, vec2) \
141 ((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2)))
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143/*
144 * allow arch override, for eg virtualized architectures (put in asm/io.h)
145 */
146#ifndef BIOVEC_PHYS_MERGEABLE
147#define BIOVEC_PHYS_MERGEABLE(vec1, vec2) \
Jeremy Fitzhardingef92131c2008-10-29 14:10:51 +0100148 __BIOVEC_PHYS_MERGEABLE(vec1, vec2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#endif
150
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
152 (((addr1) | (mask)) == (((addr2) - 1) | (mask)))
153#define BIOVEC_SEG_BOUNDARY(q, b1, b2) \
Martin K. Petersenae03bf62009-05-22 17:17:50 -0400154 __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, queue_segment_boundary((q)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Jens Axboe66cb45a2014-06-24 16:22:24 -0600156/*
Kent Overstreetd74c6d52013-02-06 12:23:11 -0800157 * drivers should _never_ use the all version - the bio may have been split
158 * before it got to the driver and the driver won't own all of it
159 */
160#define bio_for_each_segment_all(bvl, bio, i) \
Kent Overstreetf619d252013-08-07 14:30:33 -0700161 for (i = 0, bvl = (bio)->bi_io_vec; i < (bio)->bi_vcnt; i++, bvl++)
Kent Overstreetd74c6d52013-02-06 12:23:11 -0800162
Kent Overstreet4550dd62013-08-07 14:26:21 -0700163static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter,
164 unsigned bytes)
165{
166 iter->bi_sector += bytes >> 9;
167
Mike Christie95fe6c12016-06-05 14:31:48 -0500168 if (bio_no_advance_iter(bio))
Kent Overstreet4550dd62013-08-07 14:26:21 -0700169 iter->bi_size -= bytes;
170 else
171 bvec_iter_advance(bio->bi_io_vec, iter, bytes);
172}
173
Kent Overstreet79886132013-11-23 17:19:00 -0800174#define __bio_for_each_segment(bvl, bio, iter, start) \
175 for (iter = (start); \
Kent Overstreet4550dd62013-08-07 14:26:21 -0700176 (iter).bi_size && \
177 ((bvl = bio_iter_iovec((bio), (iter))), 1); \
178 bio_advance_iter((bio), &(iter), (bvl).bv_len))
Kent Overstreet79886132013-11-23 17:19:00 -0800179
180#define bio_for_each_segment(bvl, bio, iter) \
181 __bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)
182
Kent Overstreet4550dd62013-08-07 14:26:21 -0700183#define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Shaohua Lif4595872017-03-24 10:34:43 -0700185static inline unsigned bio_segments(struct bio *bio)
Kent Overstreet458b76e2013-09-24 16:26:05 -0700186{
187 unsigned segs = 0;
188 struct bio_vec bv;
189 struct bvec_iter iter;
190
Kent Overstreet8423ae32014-02-10 17:45:50 -0800191 /*
Chaitanya Kulkarnia6f07882016-11-30 12:28:59 -0800192 * We special case discard/write same/write zeroes, because they
193 * interpret bi_size differently:
Kent Overstreet8423ae32014-02-10 17:45:50 -0800194 */
195
Chaitanya Kulkarnia6f07882016-11-30 12:28:59 -0800196 switch (bio_op(bio)) {
197 case REQ_OP_DISCARD:
198 case REQ_OP_SECURE_ERASE:
Chaitanya Kulkarnia6f07882016-11-30 12:28:59 -0800199 case REQ_OP_WRITE_ZEROES:
Christoph Hellwigf9d03f92016-12-08 15:20:32 -0700200 return 0;
201 case REQ_OP_WRITE_SAME:
Kent Overstreet8423ae32014-02-10 17:45:50 -0800202 return 1;
Chaitanya Kulkarnia6f07882016-11-30 12:28:59 -0800203 default:
204 break;
205 }
Kent Overstreet8423ae32014-02-10 17:45:50 -0800206
Shaohua Lif4595872017-03-24 10:34:43 -0700207 bio_for_each_segment(bv, bio, iter)
Kent Overstreet458b76e2013-09-24 16:26:05 -0700208 segs++;
209
210 return segs;
211}
212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213/*
214 * get a reference to a bio, so it won't disappear. the intended use is
215 * something like:
216 *
217 * bio_get(bio);
218 * submit_bio(rw, bio);
219 * if (bio->bi_flags ...)
220 * do_something
221 * bio_put(bio);
222 *
223 * without the bio_get(), it could potentially complete I/O before submit_bio
224 * returns. and then bio would be freed memory when if (bio->bi_flags ...)
225 * runs
226 */
Jens Axboedac56212015-04-17 16:23:59 -0600227static inline void bio_get(struct bio *bio)
228{
229 bio->bi_flags |= (1 << BIO_REFFED);
230 smp_mb__before_atomic();
231 atomic_inc(&bio->__bi_cnt);
232}
233
234static inline void bio_cnt_set(struct bio *bio, unsigned int count)
235{
236 if (count != 1) {
237 bio->bi_flags |= (1 << BIO_REFFED);
238 smp_mb__before_atomic();
239 }
240 atomic_set(&bio->__bi_cnt, count);
241}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
Jens Axboeb7c44ed2015-07-24 12:37:59 -0600243static inline bool bio_flagged(struct bio *bio, unsigned int bit)
244{
Jens Axboe2c68f6d2015-07-28 13:14:32 -0600245 return (bio->bi_flags & (1U << bit)) != 0;
Jens Axboeb7c44ed2015-07-24 12:37:59 -0600246}
247
248static inline void bio_set_flag(struct bio *bio, unsigned int bit)
249{
Jens Axboe2c68f6d2015-07-28 13:14:32 -0600250 bio->bi_flags |= (1U << bit);
Jens Axboeb7c44ed2015-07-24 12:37:59 -0600251}
252
253static inline void bio_clear_flag(struct bio *bio, unsigned int bit)
254{
Jens Axboe2c68f6d2015-07-28 13:14:32 -0600255 bio->bi_flags &= ~(1U << bit);
Jens Axboeb7c44ed2015-07-24 12:37:59 -0600256}
257
Ming Lei7bcd79a2016-02-26 23:40:50 +0800258static inline void bio_get_first_bvec(struct bio *bio, struct bio_vec *bv)
259{
260 *bv = bio_iovec(bio);
261}
262
263static inline void bio_get_last_bvec(struct bio *bio, struct bio_vec *bv)
264{
265 struct bvec_iter iter = bio->bi_iter;
266 int idx;
267
Ming Lei7bcd79a2016-02-26 23:40:50 +0800268 if (unlikely(!bio_multiple_segments(bio))) {
269 *bv = bio_iovec(bio);
270 return;
271 }
272
273 bio_advance_iter(bio, &iter, iter.bi_size);
274
275 if (!iter.bi_bvec_done)
276 idx = iter.bi_idx - 1;
277 else /* in the middle of bvec */
278 idx = iter.bi_idx;
279
280 *bv = bio->bi_io_vec[idx];
281
282 /*
283 * iter.bi_bvec_done records actual length of the last bvec
284 * if this bio ends in the middle of one io vector
285 */
286 if (iter.bi_bvec_done)
287 bv->bv_len = iter.bi_bvec_done;
288}
289
Martin K. Petersenc6115292014-09-26 19:20:08 -0400290enum bip_flags {
291 BIP_BLOCK_INTEGRITY = 1 << 0, /* block layer owns integrity data */
292 BIP_MAPPED_INTEGRITY = 1 << 1, /* ref tag has been remapped */
293 BIP_CTRL_NOCHECK = 1 << 2, /* disable HBA integrity checking */
294 BIP_DISK_NOCHECK = 1 << 3, /* disable disk integrity checking */
295 BIP_IP_CHECKSUM = 1 << 4, /* IP checksum */
296};
297
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200298/*
299 * bio integrity payload
300 */
301struct bio_integrity_payload {
302 struct bio *bip_bio; /* parent bio */
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200303
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800304 struct bvec_iter bip_iter;
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200305
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800306 bio_end_io_t *bip_end_io; /* saved I/O completion fn */
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200307
Martin K. Petersen7878cba2009-06-26 15:37:49 +0200308 unsigned short bip_slab; /* slab the bip came from */
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200309 unsigned short bip_vcnt; /* # of integrity bio_vecs */
Gu Zhengcbcd10542014-07-01 10:36:47 -0600310 unsigned short bip_max_vcnt; /* integrity bio_vec slots */
Martin K. Petersenb1f0138852014-09-26 19:20:04 -0400311 unsigned short bip_flags; /* control flags */
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200312
313 struct work_struct bip_work; /* I/O completion */
Kent Overstreet6fda9812012-10-12 13:18:27 -0700314
315 struct bio_vec *bip_vec;
316 struct bio_vec bip_inline_vecs[0];/* embedded bvec array */
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200317};
Martin K. Petersen18593082014-09-26 19:20:01 -0400318
Keith Busch06c1e392015-12-03 09:32:21 -0700319#if defined(CONFIG_BLK_DEV_INTEGRITY)
320
321static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
322{
Jens Axboe1eff9d32016-08-05 15:35:16 -0600323 if (bio->bi_opf & REQ_INTEGRITY)
Keith Busch06c1e392015-12-03 09:32:21 -0700324 return bio->bi_integrity;
325
326 return NULL;
327}
328
Martin K. Petersenc6115292014-09-26 19:20:08 -0400329static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
330{
331 struct bio_integrity_payload *bip = bio_integrity(bio);
332
333 if (bip)
334 return bip->bip_flags & flag;
335
336 return false;
337}
Martin K. Petersenb1f0138852014-09-26 19:20:04 -0400338
Martin K. Petersen18593082014-09-26 19:20:01 -0400339static inline sector_t bip_get_seed(struct bio_integrity_payload *bip)
340{
341 return bip->bip_iter.bi_sector;
342}
343
344static inline void bip_set_seed(struct bio_integrity_payload *bip,
345 sector_t seed)
346{
347 bip->bip_iter.bi_sector = seed;
348}
349
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200350#endif /* CONFIG_BLK_DEV_INTEGRITY */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
Kent Overstreet6678d832013-08-07 11:14:32 -0700352extern void bio_trim(struct bio *bio, int offset, int size);
Kent Overstreet20d01892013-11-23 18:21:01 -0800353extern struct bio *bio_split(struct bio *bio, int sectors,
354 gfp_t gfp, struct bio_set *bs);
355
356/**
357 * bio_next_split - get next @sectors from a bio, splitting if necessary
358 * @bio: bio to split
359 * @sectors: number of sectors to split from the front of @bio
360 * @gfp: gfp mask
361 * @bs: bio set to allocate from
362 *
363 * Returns a bio representing the next @sectors of @bio - if the bio is smaller
364 * than @sectors, returns the original bio unchanged.
365 */
366static inline struct bio *bio_next_split(struct bio *bio, int sectors,
367 gfp_t gfp, struct bio_set *bs)
368{
369 if (sectors >= bio_sectors(bio))
370 return bio;
371
372 return bio_split(bio, sectors, gfp, bs);
373}
374
NeilBrown011067b2017-06-18 14:38:57 +1000375extern struct bio_set *bioset_create(unsigned int, unsigned int, int flags);
376enum {
377 BIOSET_NEED_BVECS = BIT(0),
NeilBrown47e0fb42017-06-18 14:38:57 +1000378 BIOSET_NEED_RESCUER = BIT(1),
NeilBrown011067b2017-06-18 14:38:57 +1000379};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380extern void bioset_free(struct bio_set *);
Fabian Fredericka6c39cb4f2014-04-22 15:09:05 -0600381extern mempool_t *biovec_create_pool(int pool_entries);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Dan Carpenter7a88fa12017-03-23 13:24:55 +0300383extern struct bio *bio_alloc_bioset(gfp_t, unsigned int, struct bio_set *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384extern void bio_put(struct bio *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Kent Overstreet59d276f2013-11-23 18:19:27 -0800386extern void __bio_clone_fast(struct bio *, struct bio *);
387extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700388extern struct bio *bio_clone_bioset(struct bio *, gfp_t, struct bio_set *bs);
389
Kent Overstreet3f86a822012-09-06 15:35:01 -0700390extern struct bio_set *fs_bio_set;
391
392static inline struct bio *bio_alloc(gfp_t gfp_mask, unsigned int nr_iovecs)
393{
394 return bio_alloc_bioset(gfp_mask, nr_iovecs, fs_bio_set);
395}
396
397static inline struct bio *bio_kmalloc(gfp_t gfp_mask, unsigned int nr_iovecs)
398{
399 return bio_alloc_bioset(gfp_mask, nr_iovecs, NULL);
400}
401
Kent Overstreetbf800ef2012-09-06 15:35:02 -0700402static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
403{
404 return bio_clone_bioset(bio, gfp_mask, NULL);
405
406}
407
Christoph Hellwig1e3914d2016-11-01 07:40:12 -0600408extern blk_qc_t submit_bio(struct bio *);
409
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200410extern void bio_endio(struct bio *);
411
412static inline void bio_io_error(struct bio *bio)
413{
Christoph Hellwig4e4cbee2017-06-03 09:38:06 +0200414 bio->bi_status = BLK_STS_IOERR;
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200415 bio_endio(bio);
416}
417
Goldwyn Rodrigues03a07c92017-06-20 07:05:46 -0500418static inline void bio_wouldblock_error(struct bio *bio)
419{
420 bio->bi_status = BLK_STS_AGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 bio_endio(bio);
422}
423
NeilBrown6712ecf2007-09-27 12:47:43 +0200424struct request_queue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425extern int bio_phys_segments(struct request_queue *, struct bio *);
426
Mike Christie4e49ea42016-06-05 14:31:41 -0500427extern int submit_bio_wait(struct bio *bio);
Kent Overstreet054bdf62012-09-28 13:17:55 -0700428extern void bio_advance(struct bio *, unsigned);
429
Ming Lei3a83f462016-11-22 08:57:21 -0700430extern void bio_init(struct bio *bio, struct bio_vec *table,
431 unsigned short max_vecs);
Jens Axboe9ae3b3f52017-06-28 15:30:13 -0600432extern void bio_uninit(struct bio *);
Kent Overstreetf44b48c72012-09-06 15:34:58 -0700433extern void bio_reset(struct bio *);
Kent Overstreet196d38bc2013-11-23 18:34:15 -0800434void bio_chain(struct bio *, struct bio *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
Mike Christie6e68af62005-11-11 05:30:27 -0600437extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
438 unsigned int, unsigned int);
Kent Overstreet2cefe4d2016-10-31 11:59:24 -0600439int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter);
FUJITA Tomonori152e2832008-08-28 16:17:06 +0900440struct rq_map_data;
James Bottomley f1970ba2005-06-20 14:06:52 +0200441extern struct bio *bio_map_user_iov(struct request_queue *,
Kent Overstreet26e49cf2015-01-18 16:16:31 +0100442 const struct iov_iter *, gfp_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443extern void bio_unmap_user(struct bio *);
Mike Christie df46b9a2005-06-20 14:04:44 +0200444extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
Al Viro27496a82005-10-21 03:20:48 -0400445 gfp_t);
FUJITA Tomonori68154e92008-04-25 12:47:50 +0200446extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
447 gfp_t, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448extern void bio_set_pages_dirty(struct bio *bio);
449extern void bio_check_pages_dirty(struct bio *bio);
Ilya Loginov2d4dc892009-11-26 09:16:19 +0100450
Gu Zheng394ffa52014-11-24 11:05:22 +0800451void generic_start_io_acct(int rw, unsigned long sectors,
452 struct hd_struct *part);
453void generic_end_io_acct(int rw, struct hd_struct *part,
454 unsigned long start_time);
455
Ilya Loginov2d4dc892009-11-26 09:16:19 +0100456#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
457# error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
458#endif
459#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
460extern void bio_flush_dcache_pages(struct bio *bi);
461#else
462static inline void bio_flush_dcache_pages(struct bio *bi)
463{
464}
465#endif
466
Kent Overstreet16ac3d62012-09-10 13:57:51 -0700467extern void bio_copy_data(struct bio *dst, struct bio *src);
Kent Overstreeta0787602012-09-10 14:03:28 -0700468extern int bio_alloc_pages(struct bio *bio, gfp_t gfp);
Guoqing Jiang491221f2016-09-22 03:10:01 -0400469extern void bio_free_pages(struct bio *bio);
Kent Overstreet16ac3d62012-09-10 13:57:51 -0700470
FUJITA Tomonori152e2832008-08-28 16:17:06 +0900471extern struct bio *bio_copy_user_iov(struct request_queue *,
Al Viro86d564c2014-02-08 20:42:52 -0500472 struct rq_map_data *,
Kent Overstreet26e49cf2015-01-18 16:16:31 +0100473 const struct iov_iter *,
474 gfp_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475extern int bio_uncopy_user(struct bio *);
476void zero_fill_bio(struct bio *bio);
Kent Overstreet9f060e22012-10-12 15:29:33 -0700477extern struct bio_vec *bvec_alloc(gfp_t, int, unsigned long *, mempool_t *);
478extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200479extern unsigned int bvec_nr_vecs(unsigned short idx);
Martin K. Petersen51d654e2008-06-17 18:59:56 +0200480
Tejun Heo852c7882012-03-05 13:15:27 -0800481#ifdef CONFIG_BLK_CGROUP
Tejun Heo1d933cf2015-05-22 17:13:24 -0400482int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
Tejun Heo852c7882012-03-05 13:15:27 -0800483int bio_associate_current(struct bio *bio);
484void bio_disassociate_task(struct bio *bio);
Paolo Valente20bd7232016-07-27 07:22:05 +0200485void bio_clone_blkcg_association(struct bio *dst, struct bio *src);
Tejun Heo852c7882012-03-05 13:15:27 -0800486#else /* CONFIG_BLK_CGROUP */
Tejun Heo1d933cf2015-05-22 17:13:24 -0400487static inline int bio_associate_blkcg(struct bio *bio,
488 struct cgroup_subsys_state *blkcg_css) { return 0; }
Tejun Heo852c7882012-03-05 13:15:27 -0800489static inline int bio_associate_current(struct bio *bio) { return -ENOENT; }
490static inline void bio_disassociate_task(struct bio *bio) { }
Paolo Valente20bd7232016-07-27 07:22:05 +0200491static inline void bio_clone_blkcg_association(struct bio *dst,
492 struct bio *src) { }
Tejun Heo852c7882012-03-05 13:15:27 -0800493#endif /* CONFIG_BLK_CGROUP */
494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495#ifdef CONFIG_HIGHMEM
496/*
Alberto Bertogli20b636b2009-02-02 12:41:07 +0100497 * remember never ever reenable interrupts between a bvec_kmap_irq and
498 * bvec_kunmap_irq!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 */
Alberto Bertogli4f570f92009-11-02 11:40:16 +0100500static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
502 unsigned long addr;
503
504 /*
505 * might not be a highmem page, but the preempt/irq count
506 * balancing is a lot nicer this way
507 */
508 local_irq_save(*flags);
Cong Wange8e3c3d2011-11-25 23:14:27 +0800509 addr = (unsigned long) kmap_atomic(bvec->bv_page);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
511 BUG_ON(addr & ~PAGE_MASK);
512
513 return (char *) addr + bvec->bv_offset;
514}
515
Alberto Bertogli4f570f92009-11-02 11:40:16 +0100516static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
518 unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
519
Cong Wange8e3c3d2011-11-25 23:14:27 +0800520 kunmap_atomic((void *) ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 local_irq_restore(*flags);
522}
523
524#else
Geert Uytterhoeven11a691b2010-10-21 10:32:29 +0200525static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
526{
527 return page_address(bvec->bv_page) + bvec->bv_offset;
528}
529
530static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
531{
532 *flags = 0;
533}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534#endif
535
Kent Overstreetf619d252013-08-07 14:30:33 -0700536static inline char *__bio_kmap_irq(struct bio *bio, struct bvec_iter iter,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 unsigned long *flags)
538{
Kent Overstreetf619d252013-08-07 14:30:33 -0700539 return bvec_kmap_irq(&bio_iter_iovec(bio, iter), flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540}
541#define __bio_kunmap_irq(buf, flags) bvec_kunmap_irq(buf, flags)
542
543#define bio_kmap_irq(bio, flags) \
Kent Overstreetf619d252013-08-07 14:30:33 -0700544 __bio_kmap_irq((bio), (bio)->bi_iter, (flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545#define bio_kunmap_irq(buf,flags) __bio_kunmap_irq(buf, flags)
546
Jens Axboe7a67f632008-08-08 11:17:12 +0200547/*
Akinobu Mitae6863072009-04-17 08:41:21 +0200548 * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
Christoph Hellwig8f3d8ba2009-04-07 19:55:13 +0200549 *
550 * A bio_list anchors a singly-linked list of bios chained through the bi_next
551 * member of the bio. The bio_list also caches the last list member to allow
552 * fast access to the tail.
553 */
554struct bio_list {
555 struct bio *head;
556 struct bio *tail;
557};
558
559static inline int bio_list_empty(const struct bio_list *bl)
560{
561 return bl->head == NULL;
562}
563
564static inline void bio_list_init(struct bio_list *bl)
565{
566 bl->head = bl->tail = NULL;
567}
568
Jens Axboe320ae512013-10-24 09:20:05 +0100569#define BIO_EMPTY_LIST { NULL, NULL }
570
Christoph Hellwig8f3d8ba2009-04-07 19:55:13 +0200571#define bio_list_for_each(bio, bl) \
572 for (bio = (bl)->head; bio; bio = bio->bi_next)
573
574static inline unsigned bio_list_size(const struct bio_list *bl)
575{
576 unsigned sz = 0;
577 struct bio *bio;
578
579 bio_list_for_each(bio, bl)
580 sz++;
581
582 return sz;
583}
584
585static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
586{
587 bio->bi_next = NULL;
588
589 if (bl->tail)
590 bl->tail->bi_next = bio;
591 else
592 bl->head = bio;
593
594 bl->tail = bio;
595}
596
597static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
598{
599 bio->bi_next = bl->head;
600
601 bl->head = bio;
602
603 if (!bl->tail)
604 bl->tail = bio;
605}
606
607static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
608{
609 if (!bl2->head)
610 return;
611
612 if (bl->tail)
613 bl->tail->bi_next = bl2->head;
614 else
615 bl->head = bl2->head;
616
617 bl->tail = bl2->tail;
618}
619
620static inline void bio_list_merge_head(struct bio_list *bl,
621 struct bio_list *bl2)
622{
623 if (!bl2->head)
624 return;
625
626 if (bl->head)
627 bl2->tail->bi_next = bl->head;
628 else
629 bl->tail = bl2->tail;
630
631 bl->head = bl2->head;
632}
633
Geert Uytterhoeven13685a12009-06-10 04:38:40 +0000634static inline struct bio *bio_list_peek(struct bio_list *bl)
635{
636 return bl->head;
637}
638
Christoph Hellwig8f3d8ba2009-04-07 19:55:13 +0200639static inline struct bio *bio_list_pop(struct bio_list *bl)
640{
641 struct bio *bio = bl->head;
642
643 if (bio) {
644 bl->head = bl->head->bi_next;
645 if (!bl->head)
646 bl->tail = NULL;
647
648 bio->bi_next = NULL;
649 }
650
651 return bio;
652}
653
654static inline struct bio *bio_list_get(struct bio_list *bl)
655{
656 struct bio *bio = bl->head;
657
658 bl->head = bl->tail = NULL;
659
660 return bio;
661}
662
Kent Overstreet57fb2332012-08-24 04:56:11 -0700663/*
Mike Snitzer0ef5a502016-05-05 11:54:22 -0400664 * Increment chain count for the bio. Make sure the CHAIN flag update
665 * is visible before the raised count.
666 */
667static inline void bio_inc_remaining(struct bio *bio)
668{
669 bio_set_flag(bio, BIO_CHAIN);
670 smp_mb__before_atomic();
671 atomic_inc(&bio->__bi_remaining);
672}
673
674/*
Kent Overstreet57fb2332012-08-24 04:56:11 -0700675 * bio_set is used to allow other portions of the IO system to
676 * allocate their own private memory pools for bio and iovec structures.
677 * These memory pools in turn all allocate from the bio_slab
678 * and the bvec_slabs[].
679 */
680#define BIO_POOL_SIZE 2
Kent Overstreet57fb2332012-08-24 04:56:11 -0700681
682struct bio_set {
683 struct kmem_cache *bio_slab;
684 unsigned int front_pad;
685
686 mempool_t *bio_pool;
Kent Overstreet9f060e22012-10-12 15:29:33 -0700687 mempool_t *bvec_pool;
Kent Overstreet57fb2332012-08-24 04:56:11 -0700688#if defined(CONFIG_BLK_DEV_INTEGRITY)
689 mempool_t *bio_integrity_pool;
Kent Overstreet9f060e22012-10-12 15:29:33 -0700690 mempool_t *bvec_integrity_pool;
Kent Overstreet57fb2332012-08-24 04:56:11 -0700691#endif
Kent Overstreetdf2cb6d2012-09-10 14:33:46 -0700692
693 /*
694 * Deadlock avoidance for stacking block drivers: see comments in
695 * bio_alloc_bioset() for details
696 */
697 spinlock_t rescue_lock;
698 struct bio_list rescue_list;
699 struct work_struct rescue_work;
700 struct workqueue_struct *rescue_workqueue;
Kent Overstreet57fb2332012-08-24 04:56:11 -0700701};
702
703struct biovec_slab {
704 int nr_vecs;
705 char *name;
706 struct kmem_cache *slab;
707};
708
709/*
710 * a small number of entries is fine, not going to be performance critical.
711 * basically we just need to survive
712 */
713#define BIO_SPLIT_ENTRIES 2
714
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200715#if defined(CONFIG_BLK_DEV_INTEGRITY)
716
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800717#define bip_for_each_vec(bvl, bip, iter) \
718 for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200719
Martin K. Petersen13f05c82010-09-10 20:50:10 +0200720#define bio_for_each_integrity_vec(_bvl, _bio, _iter) \
721 for_each_bio(_bio) \
722 bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)
723
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200724extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
Kent Overstreet1e2a410f2012-09-06 15:34:56 -0700725extern void bio_integrity_free(struct bio *);
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200726extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
Dmitry Monakhove23947b2017-06-29 11:31:11 -0700727extern bool bio_integrity_prep(struct bio *);
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200728extern void bio_integrity_endio(struct bio *);
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200729extern void bio_integrity_advance(struct bio *, unsigned int);
Dmitry Monakhovfbd08e72017-06-29 11:31:10 -0700730extern void bio_integrity_trim(struct bio *);
Kent Overstreet1e2a410f2012-09-06 15:34:56 -0700731extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
Martin K. Petersen7878cba2009-06-26 15:37:49 +0200732extern int bioset_integrity_create(struct bio_set *, int);
733extern void bioset_integrity_free(struct bio_set *);
734extern void bio_integrity_init(void);
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200735
736#else /* CONFIG_BLK_DEV_INTEGRITY */
737
Martin K. Petersenc6115292014-09-26 19:20:08 -0400738static inline void *bio_integrity(struct bio *bio)
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100739{
Martin K. Petersenc6115292014-09-26 19:20:08 -0400740 return NULL;
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100741}
742
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100743static inline int bioset_integrity_create(struct bio_set *bs, int pool_size)
744{
745 return 0;
746}
747
748static inline void bioset_integrity_free (struct bio_set *bs)
749{
750 return;
751}
752
Dmitry Monakhove23947b2017-06-29 11:31:11 -0700753static inline bool bio_integrity_prep(struct bio *bio)
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100754{
Dmitry Monakhove23947b2017-06-29 11:31:11 -0700755 return true;
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100756}
757
Kent Overstreet1e2a410f2012-09-06 15:34:56 -0700758static inline void bio_integrity_free(struct bio *bio)
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100759{
760 return;
761}
762
Stephen Rothwell0c614e22011-11-16 09:21:48 +0100763static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
Kent Overstreet1e2a410f2012-09-06 15:34:56 -0700764 gfp_t gfp_mask)
Stephen Rothwell0c614e22011-11-16 09:21:48 +0100765{
766 return 0;
767}
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100768
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100769static inline void bio_integrity_advance(struct bio *bio,
770 unsigned int bytes_done)
771{
772 return;
773}
774
Dmitry Monakhovfbd08e72017-06-29 11:31:10 -0700775static inline void bio_integrity_trim(struct bio *bio)
Martin K. Petersen6898e3b2012-01-13 08:15:33 +0100776{
777 return;
778}
779
780static inline void bio_integrity_init(void)
781{
782 return;
783}
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200784
Martin K. Petersenc6115292014-09-26 19:20:08 -0400785static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
786{
787 return false;
788}
789
Keith Busch06c1e392015-12-03 09:32:21 -0700790static inline void *bio_integrity_alloc(struct bio * bio, gfp_t gfp,
791 unsigned int nr)
792{
793 return ERR_PTR(-EINVAL);
794}
795
796static inline int bio_integrity_add_page(struct bio *bio, struct page *page,
797 unsigned int len, unsigned int offset)
798{
799 return 0;
800}
801
Martin K. Petersen7ba1ba12008-06-30 20:04:41 +0200802#endif /* CONFIG_BLK_DEV_INTEGRITY */
803
David Howells02a5e0a2007-08-11 22:34:32 +0200804#endif /* CONFIG_BLOCK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805#endif /* __LINUX_BIO_H */