]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - include/linux/bio.h
rhashtable: Mark internal/private inline functions as such
[mirror_ubuntu-bionic-kernel.git] / include / linux / bio.h
CommitLineData
1da177e4
LT
1/*
2 * 2.5 block I/O model
3 *
4 * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
7cc01581 12 *
1da177e4
LT
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public Licens
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
19 */
20#ifndef __LINUX_BIO_H
21#define __LINUX_BIO_H
22
23#include <linux/highmem.h>
24#include <linux/mempool.h>
22e2c507 25#include <linux/ioprio.h>
187f1882 26#include <linux/bug.h>
1da177e4 27
02a5e0ac
DH
28#ifdef CONFIG_BLOCK
29
1da177e4
LT
30#include <asm/io.h>
31
7cc01581
TH
32/* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
33#include <linux/blk_types.h>
34
1da177e4
LT
35#define BIO_DEBUG
36
37#ifdef BIO_DEBUG
38#define BIO_BUG_ON BUG_ON
39#else
40#define BIO_BUG_ON
41#endif
42
d84a8477 43#define BIO_MAX_PAGES 256
1da177e4
LT
44#define BIO_MAX_SIZE (BIO_MAX_PAGES << PAGE_CACHE_SHIFT)
45#define BIO_MAX_SECTORS (BIO_MAX_SIZE >> 9)
46
22e2c507
JA
47/*
48 * upper 16 bits of bi_rw define the io priority of this bio
49 */
50#define BIO_PRIO_SHIFT (8 * sizeof(unsigned long) - IOPRIO_BITS)
51#define bio_prio(bio) ((bio)->bi_rw >> BIO_PRIO_SHIFT)
52#define bio_prio_valid(bio) ioprio_valid(bio_prio(bio))
53
54#define bio_set_prio(bio, prio) do { \
55 WARN_ON(prio >= (1 << IOPRIO_BITS)); \
56 (bio)->bi_rw &= ((1UL << BIO_PRIO_SHIFT) - 1); \
57 (bio)->bi_rw |= ((unsigned long) (prio) << BIO_PRIO_SHIFT); \
58} while (0)
59
1da177e4
LT
60/*
61 * various member access, note that bio_data should of course not be used
62 * on highmem page vectors
63 */
4550dd6c 64#define __bvec_iter_bvec(bvec, iter) (&(bvec)[(iter).bi_idx])
a4ad39b1 65
4550dd6c
KO
66#define bvec_iter_page(bvec, iter) \
67 (__bvec_iter_bvec((bvec), (iter))->bv_page)
68
69#define bvec_iter_len(bvec, iter) \
70 min((iter).bi_size, \
71 __bvec_iter_bvec((bvec), (iter))->bv_len - (iter).bi_bvec_done)
72
73#define bvec_iter_offset(bvec, iter) \
74 (__bvec_iter_bvec((bvec), (iter))->bv_offset + (iter).bi_bvec_done)
75
76#define bvec_iter_bvec(bvec, iter) \
77((struct bio_vec) { \
78 .bv_page = bvec_iter_page((bvec), (iter)), \
79 .bv_len = bvec_iter_len((bvec), (iter)), \
80 .bv_offset = bvec_iter_offset((bvec), (iter)), \
81})
82
83#define bio_iter_iovec(bio, iter) \
84 bvec_iter_bvec((bio)->bi_io_vec, (iter))
85
86#define bio_iter_page(bio, iter) \
87 bvec_iter_page((bio)->bi_io_vec, (iter))
88#define bio_iter_len(bio, iter) \
89 bvec_iter_len((bio)->bi_io_vec, (iter))
90#define bio_iter_offset(bio, iter) \
91 bvec_iter_offset((bio)->bi_io_vec, (iter))
92
93#define bio_page(bio) bio_iter_page((bio), (bio)->bi_iter)
94#define bio_offset(bio) bio_iter_offset((bio), (bio)->bi_iter)
95#define bio_iovec(bio) bio_iter_iovec((bio), (bio)->bi_iter)
7988613b 96
458b76ed
KO
97#define bio_multiple_segments(bio) \
98 ((bio)->bi_iter.bi_size != bio_iovec(bio).bv_len)
4f024f37
KO
99#define bio_sectors(bio) ((bio)->bi_iter.bi_size >> 9)
100#define bio_end_sector(bio) ((bio)->bi_iter.bi_sector + bio_sectors((bio)))
bf2de6f5 101
458b76ed
KO
102/*
103 * Check whether this bio carries any data or not. A NULL bio is allowed.
104 */
105static inline bool bio_has_data(struct bio *bio)
106{
107 if (bio &&
108 bio->bi_iter.bi_size &&
109 !(bio->bi_rw & REQ_DISCARD))
110 return true;
111
112 return false;
113}
114
115static inline bool bio_is_rw(struct bio *bio)
116{
117 if (!bio_has_data(bio))
118 return false;
119
120 if (bio->bi_rw & BIO_NO_ADVANCE_ITER_MASK)
121 return false;
122
123 return true;
124}
125
126static inline bool bio_mergeable(struct bio *bio)
127{
128 if (bio->bi_rw & REQ_NOMERGE_FLAGS)
129 return false;
130
131 return true;
132}
133
2e46e8b2 134static inline unsigned int bio_cur_bytes(struct bio *bio)
bf2de6f5 135{
458b76ed 136 if (bio_has_data(bio))
a4ad39b1 137 return bio_iovec(bio).bv_len;
fb2dce86 138 else /* dataless requests such as discard */
4f024f37 139 return bio->bi_iter.bi_size;
bf2de6f5
JA
140}
141
142static inline void *bio_data(struct bio *bio)
143{
458b76ed 144 if (bio_has_data(bio))
bf2de6f5
JA
145 return page_address(bio_page(bio)) + bio_offset(bio);
146
147 return NULL;
148}
1da177e4
LT
149
150/*
151 * will die
152 */
153#define bio_to_phys(bio) (page_to_phys(bio_page((bio))) + (unsigned long) bio_offset((bio)))
154#define bvec_to_phys(bv) (page_to_phys((bv)->bv_page) + (unsigned long) (bv)->bv_offset)
155
156/*
157 * queues that have highmem support enabled may still need to revert to
158 * PIO transfers occasionally and thus map high pages temporarily. For
159 * permanent PIO fall back, user is probably better off disabling highmem
160 * I/O completely on that queue (see ide-dma for example)
161 */
f619d254
KO
162#define __bio_kmap_atomic(bio, iter) \
163 (kmap_atomic(bio_iter_iovec((bio), (iter)).bv_page) + \
164 bio_iter_iovec((bio), (iter)).bv_offset)
1da177e4 165
f619d254 166#define __bio_kunmap_atomic(addr) kunmap_atomic(addr)
1da177e4
LT
167
168/*
169 * merge helpers etc
170 */
171
f92131c3
JF
172/* Default implementation of BIOVEC_PHYS_MERGEABLE */
173#define __BIOVEC_PHYS_MERGEABLE(vec1, vec2) \
174 ((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2)))
175
1da177e4
LT
176/*
177 * allow arch override, for eg virtualized architectures (put in asm/io.h)
178 */
179#ifndef BIOVEC_PHYS_MERGEABLE
180#define BIOVEC_PHYS_MERGEABLE(vec1, vec2) \
f92131c3 181 __BIOVEC_PHYS_MERGEABLE(vec1, vec2)
1da177e4
LT
182#endif
183
1da177e4
LT
184#define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
185 (((addr1) | (mask)) == (((addr2) - 1) | (mask)))
186#define BIOVEC_SEG_BOUNDARY(q, b1, b2) \
ae03bf63 187 __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, queue_segment_boundary((q)))
1da177e4 188
66cb45aa
JA
189/*
190 * Check if adding a bio_vec after bprv with offset would create a gap in
191 * the SG list. Most drivers don't care about this, but some do.
192 */
193static inline bool bvec_gap_to_prev(struct bio_vec *bprv, unsigned int offset)
194{
195 return offset || ((bprv->bv_offset + bprv->bv_len) & (PAGE_SIZE - 1));
196}
197
6712ecf8 198#define bio_io_error(bio) bio_endio((bio), -EIO)
1da177e4 199
d74c6d51
KO
200/*
201 * drivers should _never_ use the all version - the bio may have been split
202 * before it got to the driver and the driver won't own all of it
203 */
204#define bio_for_each_segment_all(bvl, bio, i) \
f619d254 205 for (i = 0, bvl = (bio)->bi_io_vec; i < (bio)->bi_vcnt; i++, bvl++)
d74c6d51 206
4550dd6c
KO
207static inline void bvec_iter_advance(struct bio_vec *bv, struct bvec_iter *iter,
208 unsigned bytes)
209{
210 WARN_ONCE(bytes > iter->bi_size,
211 "Attempted to advance past end of bvec iter\n");
212
213 while (bytes) {
214 unsigned len = min(bytes, bvec_iter_len(bv, *iter));
215
216 bytes -= len;
217 iter->bi_size -= len;
218 iter->bi_bvec_done += len;
219
220 if (iter->bi_bvec_done == __bvec_iter_bvec(bv, *iter)->bv_len) {
221 iter->bi_bvec_done = 0;
222 iter->bi_idx++;
223 }
224 }
225}
226
227#define for_each_bvec(bvl, bio_vec, iter, start) \
b7aa84d9
MP
228 for (iter = (start); \
229 (iter).bi_size && \
230 ((bvl = bvec_iter_bvec((bio_vec), (iter))), 1); \
4550dd6c
KO
231 bvec_iter_advance((bio_vec), &(iter), (bvl).bv_len))
232
233
234static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter,
235 unsigned bytes)
236{
237 iter->bi_sector += bytes >> 9;
238
239 if (bio->bi_rw & BIO_NO_ADVANCE_ITER_MASK)
240 iter->bi_size -= bytes;
241 else
242 bvec_iter_advance(bio->bi_io_vec, iter, bytes);
243}
244
7988613b
KO
245#define __bio_for_each_segment(bvl, bio, iter, start) \
246 for (iter = (start); \
4550dd6c
KO
247 (iter).bi_size && \
248 ((bvl = bio_iter_iovec((bio), (iter))), 1); \
249 bio_advance_iter((bio), &(iter), (bvl).bv_len))
7988613b
KO
250
251#define bio_for_each_segment(bvl, bio, iter) \
252 __bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)
253
4550dd6c 254#define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
1da177e4 255
458b76ed
KO
256static inline unsigned bio_segments(struct bio *bio)
257{
258 unsigned segs = 0;
259 struct bio_vec bv;
260 struct bvec_iter iter;
261
8423ae3d
KO
262 /*
263 * We special case discard/write same, because they interpret bi_size
264 * differently:
265 */
266
267 if (bio->bi_rw & REQ_DISCARD)
268 return 1;
269
270 if (bio->bi_rw & REQ_WRITE_SAME)
271 return 1;
272
458b76ed
KO
273 bio_for_each_segment(bv, bio, iter)
274 segs++;
275
276 return segs;
277}
278
1da177e4
LT
279/*
280 * get a reference to a bio, so it won't disappear. the intended use is
281 * something like:
282 *
283 * bio_get(bio);
284 * submit_bio(rw, bio);
285 * if (bio->bi_flags ...)
286 * do_something
287 * bio_put(bio);
288 *
289 * without the bio_get(), it could potentially complete I/O before submit_bio
290 * returns. and then bio would be freed memory when if (bio->bi_flags ...)
291 * runs
292 */
293#define bio_get(bio) atomic_inc(&(bio)->bi_cnt)
294
c611529e
MP
295enum bip_flags {
296 BIP_BLOCK_INTEGRITY = 1 << 0, /* block layer owns integrity data */
297 BIP_MAPPED_INTEGRITY = 1 << 1, /* ref tag has been remapped */
298 BIP_CTRL_NOCHECK = 1 << 2, /* disable HBA integrity checking */
299 BIP_DISK_NOCHECK = 1 << 3, /* disable disk integrity checking */
300 BIP_IP_CHECKSUM = 1 << 4, /* IP checksum */
301};
302
7ba1ba12 303#if defined(CONFIG_BLK_DEV_INTEGRITY)
180b2f95
MP
304
305static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
306{
307 if (bio->bi_rw & REQ_INTEGRITY)
308 return bio->bi_integrity;
309
310 return NULL;
311}
312
7ba1ba12
MP
313/*
314 * bio integrity payload
315 */
316struct bio_integrity_payload {
317 struct bio *bip_bio; /* parent bio */
7ba1ba12 318
d57a5f7c 319 struct bvec_iter bip_iter;
7ba1ba12 320
d57a5f7c 321 bio_end_io_t *bip_end_io; /* saved I/O completion fn */
7ba1ba12 322
7878cba9 323 unsigned short bip_slab; /* slab the bip came from */
7ba1ba12 324 unsigned short bip_vcnt; /* # of integrity bio_vecs */
cbcd1054 325 unsigned short bip_max_vcnt; /* integrity bio_vec slots */
b1f01388 326 unsigned short bip_flags; /* control flags */
7ba1ba12
MP
327
328 struct work_struct bip_work; /* I/O completion */
6fda981c
KO
329
330 struct bio_vec *bip_vec;
331 struct bio_vec bip_inline_vecs[0];/* embedded bvec array */
7ba1ba12 332};
18593088 333
c611529e
MP
334static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
335{
336 struct bio_integrity_payload *bip = bio_integrity(bio);
337
338 if (bip)
339 return bip->bip_flags & flag;
340
341 return false;
342}
b1f01388 343
18593088
MP
344static inline sector_t bip_get_seed(struct bio_integrity_payload *bip)
345{
346 return bip->bip_iter.bi_sector;
347}
348
349static inline void bip_set_seed(struct bio_integrity_payload *bip,
350 sector_t seed)
351{
352 bip->bip_iter.bi_sector = seed;
353}
354
7ba1ba12 355#endif /* CONFIG_BLK_DEV_INTEGRITY */
1da177e4 356
6678d83f 357extern void bio_trim(struct bio *bio, int offset, int size);
20d0189b
KO
358extern struct bio *bio_split(struct bio *bio, int sectors,
359 gfp_t gfp, struct bio_set *bs);
360
361/**
362 * bio_next_split - get next @sectors from a bio, splitting if necessary
363 * @bio: bio to split
364 * @sectors: number of sectors to split from the front of @bio
365 * @gfp: gfp mask
366 * @bs: bio set to allocate from
367 *
368 * Returns a bio representing the next @sectors of @bio - if the bio is smaller
369 * than @sectors, returns the original bio unchanged.
370 */
371static inline struct bio *bio_next_split(struct bio *bio, int sectors,
372 gfp_t gfp, struct bio_set *bs)
373{
374 if (sectors >= bio_sectors(bio))
375 return bio;
376
377 return bio_split(bio, sectors, gfp, bs);
378}
379
bb799ca0 380extern struct bio_set *bioset_create(unsigned int, unsigned int);
d8f429e1 381extern struct bio_set *bioset_create_nobvec(unsigned int, unsigned int);
1da177e4 382extern void bioset_free(struct bio_set *);
a6c39cb4 383extern mempool_t *biovec_create_pool(int pool_entries);
1da177e4 384
dd0fc66f 385extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *);
1da177e4
LT
386extern void bio_put(struct bio *);
387
59d276fe
KO
388extern void __bio_clone_fast(struct bio *, struct bio *);
389extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
bf800ef1
KO
390extern struct bio *bio_clone_bioset(struct bio *, gfp_t, struct bio_set *bs);
391
3f86a82a
KO
392extern struct bio_set *fs_bio_set;
393
394static inline struct bio *bio_alloc(gfp_t gfp_mask, unsigned int nr_iovecs)
395{
396 return bio_alloc_bioset(gfp_mask, nr_iovecs, fs_bio_set);
397}
398
bf800ef1
KO
399static inline struct bio *bio_clone(struct bio *bio, gfp_t gfp_mask)
400{
401 return bio_clone_bioset(bio, gfp_mask, fs_bio_set);
402}
403
3f86a82a
KO
404static inline struct bio *bio_kmalloc(gfp_t gfp_mask, unsigned int nr_iovecs)
405{
406 return bio_alloc_bioset(gfp_mask, nr_iovecs, NULL);
407}
408
bf800ef1
KO
409static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
410{
411 return bio_clone_bioset(bio, gfp_mask, NULL);
412
413}
414
6712ecf8 415extern void bio_endio(struct bio *, int);
196d38bc 416extern void bio_endio_nodec(struct bio *, int);
1da177e4
LT
417struct request_queue;
418extern int bio_phys_segments(struct request_queue *, struct bio *);
1da177e4 419
9e882242 420extern int submit_bio_wait(int rw, struct bio *bio);
054bdf64
KO
421extern void bio_advance(struct bio *, unsigned);
422
1da177e4 423extern void bio_init(struct bio *);
f44b48c7 424extern void bio_reset(struct bio *);
196d38bc 425void bio_chain(struct bio *, struct bio *);
1da177e4
LT
426
427extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
6e68af66
MC
428extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
429 unsigned int, unsigned int);
1da177e4 430extern int bio_get_nr_vecs(struct block_device *);
152e283f 431struct rq_map_data;
f1970baf 432extern struct bio *bio_map_user_iov(struct request_queue *,
26e49cfc 433 const struct iov_iter *, gfp_t);
1da177e4 434extern void bio_unmap_user(struct bio *);
df46b9a4 435extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
27496a8c 436 gfp_t);
68154e90
FT
437extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
438 gfp_t, int);
1da177e4
LT
439extern void bio_set_pages_dirty(struct bio *bio);
440extern void bio_check_pages_dirty(struct bio *bio);
2d4dc890 441
394ffa50
GZ
442void generic_start_io_acct(int rw, unsigned long sectors,
443 struct hd_struct *part);
444void generic_end_io_acct(int rw, struct hd_struct *part,
445 unsigned long start_time);
446
2d4dc890
IL
447#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
448# error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
449#endif
450#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
451extern void bio_flush_dcache_pages(struct bio *bi);
452#else
453static inline void bio_flush_dcache_pages(struct bio *bi)
454{
455}
456#endif
457
16ac3d63 458extern void bio_copy_data(struct bio *dst, struct bio *src);
a0787606 459extern int bio_alloc_pages(struct bio *bio, gfp_t gfp);
16ac3d63 460
152e283f 461extern struct bio *bio_copy_user_iov(struct request_queue *,
86d564c8 462 struct rq_map_data *,
26e49cfc
KO
463 const struct iov_iter *,
464 gfp_t);
1da177e4
LT
465extern int bio_uncopy_user(struct bio *);
466void zero_fill_bio(struct bio *bio);
9f060e22
KO
467extern struct bio_vec *bvec_alloc(gfp_t, int, unsigned long *, mempool_t *);
468extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
7ba1ba12 469extern unsigned int bvec_nr_vecs(unsigned short idx);
51d654e1 470
852c788f
TH
471#ifdef CONFIG_BLK_CGROUP
472int bio_associate_current(struct bio *bio);
473void bio_disassociate_task(struct bio *bio);
474#else /* CONFIG_BLK_CGROUP */
475static inline int bio_associate_current(struct bio *bio) { return -ENOENT; }
476static inline void bio_disassociate_task(struct bio *bio) { }
477#endif /* CONFIG_BLK_CGROUP */
478
1da177e4
LT
479#ifdef CONFIG_HIGHMEM
480/*
20b636bf
AB
481 * remember never ever reenable interrupts between a bvec_kmap_irq and
482 * bvec_kunmap_irq!
1da177e4 483 */
4f570f99 484static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
1da177e4
LT
485{
486 unsigned long addr;
487
488 /*
489 * might not be a highmem page, but the preempt/irq count
490 * balancing is a lot nicer this way
491 */
492 local_irq_save(*flags);
e8e3c3d6 493 addr = (unsigned long) kmap_atomic(bvec->bv_page);
1da177e4
LT
494
495 BUG_ON(addr & ~PAGE_MASK);
496
497 return (char *) addr + bvec->bv_offset;
498}
499
4f570f99 500static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
1da177e4
LT
501{
502 unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
503
e8e3c3d6 504 kunmap_atomic((void *) ptr);
1da177e4
LT
505 local_irq_restore(*flags);
506}
507
508#else
11a691be
GU
509static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
510{
511 return page_address(bvec->bv_page) + bvec->bv_offset;
512}
513
514static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
515{
516 *flags = 0;
517}
1da177e4
LT
518#endif
519
f619d254 520static inline char *__bio_kmap_irq(struct bio *bio, struct bvec_iter iter,
1da177e4
LT
521 unsigned long *flags)
522{
f619d254 523 return bvec_kmap_irq(&bio_iter_iovec(bio, iter), flags);
1da177e4
LT
524}
525#define __bio_kunmap_irq(buf, flags) bvec_kunmap_irq(buf, flags)
526
527#define bio_kmap_irq(bio, flags) \
f619d254 528 __bio_kmap_irq((bio), (bio)->bi_iter, (flags))
1da177e4
LT
529#define bio_kunmap_irq(buf,flags) __bio_kunmap_irq(buf, flags)
530
8f3d8ba2 531/*
e686307f 532 * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
8f3d8ba2
CH
533 *
534 * A bio_list anchors a singly-linked list of bios chained through the bi_next
535 * member of the bio. The bio_list also caches the last list member to allow
536 * fast access to the tail.
537 */
538struct bio_list {
539 struct bio *head;
540 struct bio *tail;
541};
542
543static inline int bio_list_empty(const struct bio_list *bl)
544{
545 return bl->head == NULL;
546}
547
548static inline void bio_list_init(struct bio_list *bl)
549{
550 bl->head = bl->tail = NULL;
551}
552
320ae51f
JA
553#define BIO_EMPTY_LIST { NULL, NULL }
554
8f3d8ba2
CH
555#define bio_list_for_each(bio, bl) \
556 for (bio = (bl)->head; bio; bio = bio->bi_next)
557
558static inline unsigned bio_list_size(const struct bio_list *bl)
559{
560 unsigned sz = 0;
561 struct bio *bio;
562
563 bio_list_for_each(bio, bl)
564 sz++;
565
566 return sz;
567}
568
569static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
570{
571 bio->bi_next = NULL;
572
573 if (bl->tail)
574 bl->tail->bi_next = bio;
575 else
576 bl->head = bio;
577
578 bl->tail = bio;
579}
580
581static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
582{
583 bio->bi_next = bl->head;
584
585 bl->head = bio;
586
587 if (!bl->tail)
588 bl->tail = bio;
589}
590
591static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
592{
593 if (!bl2->head)
594 return;
595
596 if (bl->tail)
597 bl->tail->bi_next = bl2->head;
598 else
599 bl->head = bl2->head;
600
601 bl->tail = bl2->tail;
602}
603
604static inline void bio_list_merge_head(struct bio_list *bl,
605 struct bio_list *bl2)
606{
607 if (!bl2->head)
608 return;
609
610 if (bl->head)
611 bl2->tail->bi_next = bl->head;
612 else
613 bl->tail = bl2->tail;
614
615 bl->head = bl2->head;
616}
617
13685a16
GU
618static inline struct bio *bio_list_peek(struct bio_list *bl)
619{
620 return bl->head;
621}
622
8f3d8ba2
CH
623static inline struct bio *bio_list_pop(struct bio_list *bl)
624{
625 struct bio *bio = bl->head;
626
627 if (bio) {
628 bl->head = bl->head->bi_next;
629 if (!bl->head)
630 bl->tail = NULL;
631
632 bio->bi_next = NULL;
633 }
634
635 return bio;
636}
637
638static inline struct bio *bio_list_get(struct bio_list *bl)
639{
640 struct bio *bio = bl->head;
641
642 bl->head = bl->tail = NULL;
643
644 return bio;
645}
646
57fb233f
KO
647/*
648 * bio_set is used to allow other portions of the IO system to
649 * allocate their own private memory pools for bio and iovec structures.
650 * These memory pools in turn all allocate from the bio_slab
651 * and the bvec_slabs[].
652 */
653#define BIO_POOL_SIZE 2
654#define BIOVEC_NR_POOLS 6
655#define BIOVEC_MAX_IDX (BIOVEC_NR_POOLS - 1)
656
657struct bio_set {
658 struct kmem_cache *bio_slab;
659 unsigned int front_pad;
660
661 mempool_t *bio_pool;
9f060e22 662 mempool_t *bvec_pool;
57fb233f
KO
663#if defined(CONFIG_BLK_DEV_INTEGRITY)
664 mempool_t *bio_integrity_pool;
9f060e22 665 mempool_t *bvec_integrity_pool;
57fb233f 666#endif
df2cb6da
KO
667
668 /*
669 * Deadlock avoidance for stacking block drivers: see comments in
670 * bio_alloc_bioset() for details
671 */
672 spinlock_t rescue_lock;
673 struct bio_list rescue_list;
674 struct work_struct rescue_work;
675 struct workqueue_struct *rescue_workqueue;
57fb233f
KO
676};
677
678struct biovec_slab {
679 int nr_vecs;
680 char *name;
681 struct kmem_cache *slab;
682};
683
684/*
685 * a small number of entries is fine, not going to be performance critical.
686 * basically we just need to survive
687 */
688#define BIO_SPLIT_ENTRIES 2
689
7ba1ba12
MP
690#if defined(CONFIG_BLK_DEV_INTEGRITY)
691
d57a5f7c
KO
692#define bip_for_each_vec(bvl, bip, iter) \
693 for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)
7ba1ba12 694
13f05c8d
MP
695#define bio_for_each_integrity_vec(_bvl, _bio, _iter) \
696 for_each_bio(_bio) \
697 bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)
698
7ba1ba12 699extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
1e2a410f 700extern void bio_integrity_free(struct bio *);
7ba1ba12 701extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
e7258c1a 702extern bool bio_integrity_enabled(struct bio *bio);
7ba1ba12
MP
703extern int bio_integrity_prep(struct bio *);
704extern void bio_integrity_endio(struct bio *, int);
705extern void bio_integrity_advance(struct bio *, unsigned int);
706extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int);
1e2a410f 707extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
7878cba9
MP
708extern int bioset_integrity_create(struct bio_set *, int);
709extern void bioset_integrity_free(struct bio_set *);
710extern void bio_integrity_init(void);
7ba1ba12
MP
711
712#else /* CONFIG_BLK_DEV_INTEGRITY */
713
c611529e 714static inline void *bio_integrity(struct bio *bio)
6898e3bd 715{
c611529e 716 return NULL;
6898e3bd
MP
717}
718
e7258c1a 719static inline bool bio_integrity_enabled(struct bio *bio)
6898e3bd 720{
e7258c1a 721 return false;
6898e3bd
MP
722}
723
724static inline int bioset_integrity_create(struct bio_set *bs, int pool_size)
725{
726 return 0;
727}
728
729static inline void bioset_integrity_free (struct bio_set *bs)
730{
731 return;
732}
733
734static inline int bio_integrity_prep(struct bio *bio)
735{
736 return 0;
737}
738
1e2a410f 739static inline void bio_integrity_free(struct bio *bio)
6898e3bd
MP
740{
741 return;
742}
743
0c614e2d 744static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
1e2a410f 745 gfp_t gfp_mask)
0c614e2d
SR
746{
747 return 0;
748}
6898e3bd 749
6898e3bd
MP
750static inline void bio_integrity_advance(struct bio *bio,
751 unsigned int bytes_done)
752{
753 return;
754}
755
756static inline void bio_integrity_trim(struct bio *bio, unsigned int offset,
757 unsigned int sectors)
758{
759 return;
760}
761
762static inline void bio_integrity_init(void)
763{
764 return;
765}
7ba1ba12 766
c611529e
MP
767static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
768{
769 return false;
770}
771
7ba1ba12
MP
772#endif /* CONFIG_BLK_DEV_INTEGRITY */
773
02a5e0ac 774#endif /* CONFIG_BLOCK */
1da177e4 775#endif /* __LINUX_BIO_H */