2019-04-30 18:42:39 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2001 Jens Axboe <axboe@suse.de>
|
|
|
|
|
*/
|
|
|
|
|
#ifndef __LINUX_BIO_H
|
|
|
|
|
#define __LINUX_BIO_H
|
|
|
|
|
|
|
|
|
|
#include <linux/mempool.h>
|
2010-08-03 11:14:58 +00:00
|
|
|
/* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
|
|
|
|
|
#include <linux/blk_types.h>
|
2021-01-09 16:03:02 +00:00
|
|
|
#include <linux/uio.h>
|
2010-08-03 11:14:58 +00:00
|
|
|
|
2021-03-11 11:01:37 +00:00
|
|
|
#define BIO_MAX_VECS 256U
|
2021-01-29 04:38:57 +00:00
|
|
|
|
2023-01-21 06:49:58 +00:00
|
|
|
struct queue_limits;
|
|
|
|
|
|
2021-01-29 04:38:57 +00:00
|
|
|
static inline unsigned int bio_max_segs(unsigned int nr_segs)
|
|
|
|
|
{
|
2021-03-11 11:01:37 +00:00
|
|
|
return min(nr_segs, BIO_MAX_VECS);
|
2021-01-29 04:38:57 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-06-05 19:32:20 +00:00
|
|
|
#define bio_prio(bio) (bio)->bi_ioprio
|
|
|
|
|
#define bio_set_prio(bio, prio) ((bio)->bi_ioprio = prio)
|
2005-06-27 08:55:12 +00:00
|
|
|
|
2013-08-07 21:26:21 +00:00
|
|
|
#define bio_iter_iovec(bio, iter) \
|
|
|
|
|
bvec_iter_bvec((bio)->bi_io_vec, (iter))
|
|
|
|
|
|
|
|
|
|
#define bio_iter_page(bio, iter) \
|
|
|
|
|
bvec_iter_page((bio)->bi_io_vec, (iter))
|
|
|
|
|
#define bio_iter_len(bio, iter) \
|
|
|
|
|
bvec_iter_len((bio)->bi_io_vec, (iter))
|
|
|
|
|
#define bio_iter_offset(bio, iter) \
|
|
|
|
|
bvec_iter_offset((bio)->bi_io_vec, (iter))
|
|
|
|
|
|
|
|
|
|
#define bio_page(bio) bio_iter_page((bio), (bio)->bi_iter)
|
|
|
|
|
#define bio_offset(bio) bio_iter_offset((bio), (bio)->bi_iter)
|
|
|
|
|
#define bio_iovec(bio) bio_iter_iovec((bio), (bio)->bi_iter)
|
2013-11-24 01:19:00 +00:00
|
|
|
|
2018-05-09 01:33:53 +00:00
|
|
|
#define bvec_iter_sectors(iter) ((iter).bi_size >> 9)
|
|
|
|
|
#define bvec_iter_end_sector(iter) ((iter).bi_sector + bvec_iter_sectors((iter)))
|
|
|
|
|
|
|
|
|
|
#define bio_sectors(bio) bvec_iter_sectors((bio)->bi_iter)
|
|
|
|
|
#define bio_end_sector(bio) bvec_iter_end_sector((bio)->bi_iter)
|
2007-09-27 11:01:25 +00:00
|
|
|
|
2016-11-01 13:40:11 +00:00
|
|
|
/*
|
|
|
|
|
* Return the data direction, READ or WRITE.
|
|
|
|
|
*/
|
|
|
|
|
#define bio_data_dir(bio) \
|
|
|
|
|
(op_is_write(bio_op(bio)) ? WRITE : READ)
|
|
|
|
|
|
2013-09-24 23:26:05 +00:00
|
|
|
/*
|
|
|
|
|
* Check whether this bio carries any data or not. A NULL bio is allowed.
|
|
|
|
|
*/
|
|
|
|
|
static inline bool bio_has_data(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
if (bio &&
|
|
|
|
|
bio->bi_iter.bi_size &&
|
2016-08-16 07:59:35 +00:00
|
|
|
bio_op(bio) != REQ_OP_DISCARD &&
|
2016-11-30 20:28:59 +00:00
|
|
|
bio_op(bio) != REQ_OP_SECURE_ERASE &&
|
|
|
|
|
bio_op(bio) != REQ_OP_WRITE_ZEROES)
|
2013-09-24 23:26:05 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2020-05-19 04:07:35 +00:00
|
|
|
static inline bool bio_no_advance_iter(const struct bio *bio)
|
2016-06-05 19:31:48 +00:00
|
|
|
{
|
2016-08-16 07:59:35 +00:00
|
|
|
return bio_op(bio) == REQ_OP_DISCARD ||
|
|
|
|
|
bio_op(bio) == REQ_OP_SECURE_ERASE ||
|
2016-11-30 20:28:59 +00:00
|
|
|
bio_op(bio) == REQ_OP_WRITE_ZEROES;
|
2016-06-05 19:31:48 +00:00
|
|
|
}
|
|
|
|
|
|
2007-09-27 11:01:25 +00:00
|
|
|
static inline void *bio_data(struct bio *bio)
|
|
|
|
|
{
|
2013-09-24 23:26:05 +00:00
|
|
|
if (bio_has_data(bio))
|
2007-09-27 11:01:25 +00:00
|
|
|
return page_address(bio_page(bio)) + bio_offset(bio);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-04-08 11:02:38 +00:00
|
|
|
static inline bool bio_next_segment(const struct bio *bio,
|
|
|
|
|
struct bvec_iter_all *iter)
|
|
|
|
|
{
|
|
|
|
|
if (iter->idx >= bio->bi_vcnt)
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
bvec_advance(&bio->bi_io_vec[iter->idx], iter);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2019-02-15 11:13:19 +00:00
|
|
|
|
2013-02-06 20:23:11 +00:00
|
|
|
/*
|
|
|
|
|
* drivers should _never_ use the all version - the bio may have been split
|
|
|
|
|
* before it got to the driver and the driver won't own all of it
|
|
|
|
|
*/
|
2019-04-25 07:03:00 +00:00
|
|
|
#define bio_for_each_segment_all(bvl, bio, iter) \
|
|
|
|
|
for (bvl = bvec_init_iter_all(&iter); bio_next_segment((bio), &iter); )
|
2013-02-06 20:23:11 +00:00
|
|
|
|
2020-05-19 04:07:35 +00:00
|
|
|
static inline void bio_advance_iter(const struct bio *bio,
|
|
|
|
|
struct bvec_iter *iter, unsigned int bytes)
|
2013-08-07 21:26:21 +00:00
|
|
|
{
|
|
|
|
|
iter->bi_sector += bytes >> 9;
|
|
|
|
|
|
2018-09-05 21:45:54 +00:00
|
|
|
if (bio_no_advance_iter(bio))
|
2013-08-07 21:26:21 +00:00
|
|
|
iter->bi_size -= bytes;
|
2018-09-05 21:45:54 +00:00
|
|
|
else
|
2013-08-07 21:26:21 +00:00
|
|
|
bvec_iter_advance(bio->bi_io_vec, iter, bytes);
|
2017-06-29 18:31:13 +00:00
|
|
|
/* TODO: It is reasonable to complete bio with error here. */
|
2017-06-29 18:31:14 +00:00
|
|
|
}
|
|
|
|
|
|
2020-11-24 17:58:13 +00:00
|
|
|
/* @bytes should be less or equal to bvec[i->bi_idx].bv_len */
|
|
|
|
|
static inline void bio_advance_iter_single(const struct bio *bio,
|
|
|
|
|
struct bvec_iter *iter,
|
|
|
|
|
unsigned int bytes)
|
|
|
|
|
{
|
|
|
|
|
iter->bi_sector += bytes >> 9;
|
|
|
|
|
|
|
|
|
|
if (bio_no_advance_iter(bio))
|
|
|
|
|
iter->bi_size -= bytes;
|
|
|
|
|
else
|
|
|
|
|
bvec_iter_advance_single(bio->bi_io_vec, iter, bytes);
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-13 15:01:43 +00:00
|
|
|
void __bio_advance(struct bio *, unsigned bytes);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* bio_advance - increment/complete a bio by some number of bytes
|
|
|
|
|
* @bio: bio to advance
|
2021-12-22 21:15:32 +00:00
|
|
|
* @nbytes: number of bytes to complete
|
2021-10-13 15:01:43 +00:00
|
|
|
*
|
|
|
|
|
* This updates bi_sector, bi_size and bi_idx; if the number of bytes to
|
|
|
|
|
* complete doesn't align with a bvec boundary, then bv_len and bv_offset will
|
|
|
|
|
* be updated on the last bvec as well.
|
|
|
|
|
*
|
|
|
|
|
* @bio will then represent the remaining, uncompleted portion of the io.
|
|
|
|
|
*/
|
|
|
|
|
static inline void bio_advance(struct bio *bio, unsigned int nbytes)
|
|
|
|
|
{
|
|
|
|
|
if (nbytes == bio->bi_iter.bi_size) {
|
|
|
|
|
bio->bi_iter.bi_size = 0;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
__bio_advance(bio, nbytes);
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-24 01:19:00 +00:00
|
|
|
#define __bio_for_each_segment(bvl, bio, iter, start) \
|
|
|
|
|
for (iter = (start); \
|
2013-08-07 21:26:21 +00:00
|
|
|
(iter).bi_size && \
|
|
|
|
|
((bvl = bio_iter_iovec((bio), (iter))), 1); \
|
2020-11-24 17:58:13 +00:00
|
|
|
bio_advance_iter_single((bio), &(iter), (bvl).bv_len))
|
2013-11-24 01:19:00 +00:00
|
|
|
|
|
|
|
|
#define bio_for_each_segment(bvl, bio, iter) \
|
|
|
|
|
__bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)
|
|
|
|
|
|
2019-02-15 11:13:11 +00:00
|
|
|
#define __bio_for_each_bvec(bvl, bio, iter, start) \
|
|
|
|
|
for (iter = (start); \
|
|
|
|
|
(iter).bi_size && \
|
|
|
|
|
((bvl = mp_bvec_iter_bvec((bio)->bi_io_vec, (iter))), 1); \
|
2020-11-24 17:58:13 +00:00
|
|
|
bio_advance_iter_single((bio), &(iter), (bvl).bv_len))
|
2019-02-15 11:13:11 +00:00
|
|
|
|
|
|
|
|
/* iterate over multi-page bvec */
|
|
|
|
|
#define bio_for_each_bvec(bvl, bio, iter) \
|
|
|
|
|
__bio_for_each_bvec(bvl, bio, iter, (bio)->bi_iter)
|
|
|
|
|
|
2020-04-16 21:46:11 +00:00
|
|
|
/*
|
|
|
|
|
* Iterate over all multi-page bvecs. Drivers shouldn't use this version for the
|
|
|
|
|
* same reasons as bio_for_each_segment_all().
|
|
|
|
|
*/
|
|
|
|
|
#define bio_for_each_bvec_all(bvl, bio, i) \
|
|
|
|
|
for (i = 0, bvl = bio_first_bvec_all(bio); \
|
2021-01-04 15:58:17 +00:00
|
|
|
i < (bio)->bi_vcnt; i++, bvl++)
|
2020-04-16 21:46:11 +00:00
|
|
|
|
2013-08-07 21:26:21 +00:00
|
|
|
#define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-03-24 17:34:43 +00:00
|
|
|
static inline unsigned bio_segments(struct bio *bio)
|
2013-09-24 23:26:05 +00:00
|
|
|
{
|
|
|
|
|
unsigned segs = 0;
|
|
|
|
|
struct bio_vec bv;
|
|
|
|
|
struct bvec_iter iter;
|
|
|
|
|
|
2014-02-11 01:45:50 +00:00
|
|
|
/*
|
2016-11-30 20:28:59 +00:00
|
|
|
* We special case discard/write same/write zeroes, because they
|
|
|
|
|
* interpret bi_size differently:
|
2014-02-11 01:45:50 +00:00
|
|
|
*/
|
|
|
|
|
|
2016-11-30 20:28:59 +00:00
|
|
|
switch (bio_op(bio)) {
|
|
|
|
|
case REQ_OP_DISCARD:
|
|
|
|
|
case REQ_OP_SECURE_ERASE:
|
|
|
|
|
case REQ_OP_WRITE_ZEROES:
|
2016-12-08 22:20:32 +00:00
|
|
|
return 0;
|
2016-11-30 20:28:59 +00:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
2014-02-11 01:45:50 +00:00
|
|
|
|
2017-03-24 17:34:43 +00:00
|
|
|
bio_for_each_segment(bv, bio, iter)
|
2013-09-24 23:26:05 +00:00
|
|
|
segs++;
|
|
|
|
|
|
|
|
|
|
return segs;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* get a reference to a bio, so it won't disappear. the intended use is
|
|
|
|
|
* something like:
|
|
|
|
|
*
|
|
|
|
|
* bio_get(bio);
|
|
|
|
|
* submit_bio(rw, bio);
|
|
|
|
|
* if (bio->bi_flags ...)
|
|
|
|
|
* do_something
|
|
|
|
|
* bio_put(bio);
|
|
|
|
|
*
|
|
|
|
|
* without the bio_get(), it could potentially complete I/O before submit_bio
|
|
|
|
|
* returns. and then bio would be freed memory when if (bio->bi_flags ...)
|
|
|
|
|
* runs
|
|
|
|
|
*/
|
2015-04-17 22:23:59 +00:00
|
|
|
static inline void bio_get(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
bio->bi_flags |= (1 << BIO_REFFED);
|
|
|
|
|
smp_mb__before_atomic();
|
|
|
|
|
atomic_inc(&bio->__bi_cnt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_cnt_set(struct bio *bio, unsigned int count)
|
|
|
|
|
{
|
|
|
|
|
if (count != 1) {
|
|
|
|
|
bio->bi_flags |= (1 << BIO_REFFED);
|
2019-05-20 17:23:56 +00:00
|
|
|
smp_mb();
|
2015-04-17 22:23:59 +00:00
|
|
|
}
|
|
|
|
|
atomic_set(&bio->__bi_cnt, count);
|
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-07-24 18:37:59 +00:00
|
|
|
static inline bool bio_flagged(struct bio *bio, unsigned int bit)
|
|
|
|
|
{
|
block: Fix bio_flagged() so that gcc can better optimise it
Fix bio_flagged() so that multiple instances of it, such as:
if (bio_flagged(bio, BIO_PAGE_REFFED) ||
bio_flagged(bio, BIO_PAGE_PINNED))
can be combined by the gcc optimiser into a single test in assembly
(arguably, this is a compiler optimisation issue[1]).
The missed optimisation stems from bio_flagged() comparing the result of
the bitwise-AND to zero. This results in an out-of-line bio_release_page()
being compiled to something like:
<+0>: mov 0x14(%rdi),%eax
<+3>: test $0x1,%al
<+5>: jne 0xffffffff816dac53 <bio_release_pages+11>
<+7>: test $0x2,%al
<+9>: je 0xffffffff816dac5c <bio_release_pages+20>
<+11>: movzbl %sil,%esi
<+15>: jmp 0xffffffff816daba1 <__bio_release_pages>
<+20>: jmp 0xffffffff81d0b800 <__x86_return_thunk>
However, the test is superfluous as the return type is bool. Removing it
results in:
<+0>: testb $0x3,0x14(%rdi)
<+4>: je 0xffffffff816e4af4 <bio_release_pages+15>
<+6>: movzbl %sil,%esi
<+10>: jmp 0xffffffff816dab7c <__bio_release_pages>
<+15>: jmp 0xffffffff81d0b7c0 <__x86_return_thunk>
instead.
Also, the MOVZBL instruction looks unnecessary[2] - I think it's just
're-booling' the mark_dirty parameter.
Signed-off-by: David Howells <dhowells@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: John Hubbard <jhubbard@nvidia.com>
cc: Jens Axboe <axboe@kernel.dk>
cc: linux-block@vger.kernel.org
Link: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108370 [1]
Link: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108371 [2]
Link: https://lore.kernel.org/r/167391056756.2311931.356007731815807265.stgit@warthog.procyon.org.uk/ # v6
Reviewed-by: Christian Brauner <brauner@kernel.org>
Reviewed-by: Jan Kara <jack@suse.cz>
Link: https://lore.kernel.org/r/20230522205744.2825689-3-dhowells@redhat.com
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2023-05-22 20:57:40 +00:00
|
|
|
return bio->bi_flags & (1U << bit);
|
2015-07-24 18:37:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_set_flag(struct bio *bio, unsigned int bit)
|
|
|
|
|
{
|
2015-07-28 19:14:32 +00:00
|
|
|
bio->bi_flags |= (1U << bit);
|
2015-07-24 18:37:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_clear_flag(struct bio *bio, unsigned int bit)
|
|
|
|
|
{
|
2015-07-28 19:14:32 +00:00
|
|
|
bio->bi_flags &= ~(1U << bit);
|
2015-07-24 18:37:59 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-18 12:22:03 +00:00
|
|
|
static inline struct bio_vec *bio_first_bvec_all(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
|
|
|
|
|
return bio->bi_io_vec;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct page *bio_first_page_all(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
return bio_first_bvec_all(bio)->bv_page;
|
|
|
|
|
}
|
|
|
|
|
|
2023-07-21 03:44:44 +00:00
|
|
|
static inline struct folio *bio_first_folio_all(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
return page_folio(bio_first_page_all(bio));
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-18 12:22:03 +00:00
|
|
|
static inline struct bio_vec *bio_last_bvec_all(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
|
|
|
|
|
return &bio->bi_io_vec[bio->bi_vcnt - 1];
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-04 15:58:17 +00:00
|
|
|
/**
|
|
|
|
|
* struct folio_iter - State for iterating all folios in a bio.
|
|
|
|
|
* @folio: The current folio we're iterating. NULL after the last folio.
|
|
|
|
|
* @offset: The byte offset within the current folio.
|
|
|
|
|
* @length: The number of bytes in this iteration (will not cross folio
|
|
|
|
|
* boundary).
|
|
|
|
|
*/
|
|
|
|
|
struct folio_iter {
|
|
|
|
|
struct folio *folio;
|
|
|
|
|
size_t offset;
|
|
|
|
|
size_t length;
|
|
|
|
|
/* private: for use by the iterator */
|
2022-05-03 04:09:31 +00:00
|
|
|
struct folio *_next;
|
2021-01-04 15:58:17 +00:00
|
|
|
size_t _seg_count;
|
|
|
|
|
int _i;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline void bio_first_folio(struct folio_iter *fi, struct bio *bio,
|
|
|
|
|
int i)
|
|
|
|
|
{
|
|
|
|
|
struct bio_vec *bvec = bio_first_bvec_all(bio) + i;
|
|
|
|
|
|
2024-01-16 21:29:59 +00:00
|
|
|
if (unlikely(i >= bio->bi_vcnt)) {
|
|
|
|
|
fi->folio = NULL;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-04 15:58:17 +00:00
|
|
|
fi->folio = page_folio(bvec->bv_page);
|
|
|
|
|
fi->offset = bvec->bv_offset +
|
|
|
|
|
PAGE_SIZE * (bvec->bv_page - &fi->folio->page);
|
|
|
|
|
fi->_seg_count = bvec->bv_len;
|
|
|
|
|
fi->length = min(folio_size(fi->folio) - fi->offset, fi->_seg_count);
|
2022-05-03 04:09:31 +00:00
|
|
|
fi->_next = folio_next(fi->folio);
|
2021-01-04 15:58:17 +00:00
|
|
|
fi->_i = i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_next_folio(struct folio_iter *fi, struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
fi->_seg_count -= fi->length;
|
|
|
|
|
if (fi->_seg_count) {
|
2022-05-03 04:09:31 +00:00
|
|
|
fi->folio = fi->_next;
|
2021-01-04 15:58:17 +00:00
|
|
|
fi->offset = 0;
|
|
|
|
|
fi->length = min(folio_size(fi->folio), fi->_seg_count);
|
2022-05-03 04:09:31 +00:00
|
|
|
fi->_next = folio_next(fi->folio);
|
2021-01-04 15:58:17 +00:00
|
|
|
} else {
|
2024-01-16 21:29:59 +00:00
|
|
|
bio_first_folio(fi, bio, fi->_i + 1);
|
2021-01-04 15:58:17 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* bio_for_each_folio_all - Iterate over each folio in a bio.
|
|
|
|
|
* @fi: struct folio_iter which is updated for each folio.
|
|
|
|
|
* @bio: struct bio to iterate over.
|
|
|
|
|
*/
|
|
|
|
|
#define bio_for_each_folio_all(fi, bio) \
|
|
|
|
|
for (bio_first_folio(&fi, bio, 0); fi.folio; bio_next_folio(&fi, bio))
|
|
|
|
|
|
2014-09-26 23:20:08 +00:00
|
|
|
enum bip_flags {
|
|
|
|
|
BIP_BLOCK_INTEGRITY = 1 << 0, /* block layer owns integrity data */
|
|
|
|
|
BIP_MAPPED_INTEGRITY = 1 << 1, /* ref tag has been remapped */
|
|
|
|
|
BIP_CTRL_NOCHECK = 1 << 2, /* disable HBA integrity checking */
|
|
|
|
|
BIP_DISK_NOCHECK = 1 << 3, /* disable disk integrity checking */
|
|
|
|
|
BIP_IP_CHECKSUM = 1 << 4, /* IP checksum */
|
2023-11-30 21:53:06 +00:00
|
|
|
BIP_INTEGRITY_USER = 1 << 5, /* Integrity payload is user address */
|
|
|
|
|
BIP_COPY_USER = 1 << 6, /* Kernel bounce buffer in use */
|
2014-09-26 23:20:08 +00:00
|
|
|
};
|
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
/*
|
|
|
|
|
* bio integrity payload
|
|
|
|
|
*/
|
|
|
|
|
struct bio_integrity_payload {
|
|
|
|
|
struct bio *bip_bio; /* parent bio */
|
|
|
|
|
|
2013-11-24 01:20:16 +00:00
|
|
|
struct bvec_iter bip_iter;
|
2008-06-30 18:04:41 +00:00
|
|
|
|
|
|
|
|
unsigned short bip_vcnt; /* # of integrity bio_vecs */
|
2014-07-01 16:36:47 +00:00
|
|
|
unsigned short bip_max_vcnt; /* integrity bio_vec slots */
|
2014-09-26 23:20:04 +00:00
|
|
|
unsigned short bip_flags; /* control flags */
|
2008-06-30 18:04:41 +00:00
|
|
|
|
2018-09-05 21:45:54 +00:00
|
|
|
struct bvec_iter bio_iter; /* for rewinding parent bio */
|
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
struct work_struct bip_work; /* I/O completion */
|
2012-10-12 20:18:27 +00:00
|
|
|
|
|
|
|
|
struct bio_vec *bip_vec;
|
2020-03-23 21:40:21 +00:00
|
|
|
struct bio_vec bip_inline_vecs[];/* embedded bvec array */
|
2008-06-30 18:04:41 +00:00
|
|
|
};
|
2014-09-26 23:20:01 +00:00
|
|
|
|
2015-12-03 16:32:21 +00:00
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
|
|
|
|
|
|
|
|
|
static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
|
|
|
|
|
{
|
2016-08-05 21:35:16 +00:00
|
|
|
if (bio->bi_opf & REQ_INTEGRITY)
|
2015-12-03 16:32:21 +00:00
|
|
|
return bio->bi_integrity;
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-26 23:20:08 +00:00
|
|
|
static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
|
|
|
|
|
{
|
|
|
|
|
struct bio_integrity_payload *bip = bio_integrity(bio);
|
|
|
|
|
|
|
|
|
|
if (bip)
|
|
|
|
|
return bip->bip_flags & flag;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2014-09-26 23:20:04 +00:00
|
|
|
|
2014-09-26 23:20:01 +00:00
|
|
|
static inline sector_t bip_get_seed(struct bio_integrity_payload *bip)
|
|
|
|
|
{
|
|
|
|
|
return bip->bip_iter.bi_sector;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bip_set_seed(struct bio_integrity_payload *bip,
|
|
|
|
|
sector_t seed)
|
|
|
|
|
{
|
|
|
|
|
bip->bip_iter.bi_sector = seed;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
#endif /* CONFIG_BLK_DEV_INTEGRITY */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-07-21 12:43:32 +00:00
|
|
|
void bio_trim(struct bio *bio, sector_t offset, sector_t size);
|
2013-11-24 02:21:01 +00:00
|
|
|
extern struct bio *bio_split(struct bio *bio, int sectors,
|
|
|
|
|
gfp_t gfp, struct bio_set *bs);
|
2023-01-21 06:49:58 +00:00
|
|
|
struct bio *bio_split_rw(struct bio *bio, const struct queue_limits *lim,
|
|
|
|
|
unsigned *segs, struct bio_set *bs, unsigned max_bytes);
|
2013-11-24 02:21:01 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* bio_next_split - get next @sectors from a bio, splitting if necessary
|
|
|
|
|
* @bio: bio to split
|
|
|
|
|
* @sectors: number of sectors to split from the front of @bio
|
|
|
|
|
* @gfp: gfp mask
|
|
|
|
|
* @bs: bio set to allocate from
|
|
|
|
|
*
|
2021-12-22 21:15:32 +00:00
|
|
|
* Return: a bio representing the next @sectors of @bio - if the bio is smaller
|
2013-11-24 02:21:01 +00:00
|
|
|
* than @sectors, returns the original bio unchanged.
|
|
|
|
|
*/
|
|
|
|
|
static inline struct bio *bio_next_split(struct bio *bio, int sectors,
|
|
|
|
|
gfp_t gfp, struct bio_set *bs)
|
|
|
|
|
{
|
|
|
|
|
if (sectors >= bio_sectors(bio))
|
|
|
|
|
return bio;
|
|
|
|
|
|
|
|
|
|
return bio_split(bio, sectors, gfp, bs);
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-18 04:38:57 +00:00
|
|
|
enum {
|
|
|
|
|
BIOSET_NEED_BVECS = BIT(0),
|
2017-06-18 04:38:57 +00:00
|
|
|
BIOSET_NEED_RESCUER = BIT(1),
|
2021-03-08 18:37:47 +00:00
|
|
|
BIOSET_PERCPU_CACHE = BIT(2),
|
2017-06-18 04:38:57 +00:00
|
|
|
};
|
2018-05-20 22:25:58 +00:00
|
|
|
extern int bioset_init(struct bio_set *, unsigned int, unsigned int, int flags);
|
|
|
|
|
extern void bioset_exit(struct bio_set *);
|
2018-05-09 01:33:50 +00:00
|
|
|
extern int biovec_init_pool(mempool_t *pool, int pool_entries);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2022-01-24 09:11:03 +00:00
|
|
|
struct bio *bio_alloc_bioset(struct block_device *bdev, unsigned short nr_vecs,
|
2022-07-14 18:06:32 +00:00
|
|
|
blk_opf_t opf, gfp_t gfp_mask,
|
2022-01-24 09:11:03 +00:00
|
|
|
struct bio_set *bs);
|
2022-04-06 06:12:27 +00:00
|
|
|
struct bio *bio_kmalloc(unsigned short nr_vecs, gfp_t gfp_mask);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void bio_put(struct bio *);
|
|
|
|
|
|
2022-02-02 16:01:09 +00:00
|
|
|
struct bio *bio_alloc_clone(struct block_device *bdev, struct bio *bio_src,
|
|
|
|
|
gfp_t gfp, struct bio_set *bs);
|
|
|
|
|
int bio_init_clone(struct block_device *bdev, struct bio *bio,
|
|
|
|
|
struct bio *bio_src, gfp_t gfp);
|
2012-09-06 22:35:02 +00:00
|
|
|
|
2018-05-09 01:33:52 +00:00
|
|
|
extern struct bio_set fs_bio_set;
|
2012-09-06 22:35:01 +00:00
|
|
|
|
2022-01-24 09:11:05 +00:00
|
|
|
static inline struct bio *bio_alloc(struct block_device *bdev,
|
2022-07-14 18:06:32 +00:00
|
|
|
unsigned short nr_vecs, blk_opf_t opf, gfp_t gfp_mask)
|
2012-09-06 22:35:01 +00:00
|
|
|
{
|
2022-01-24 09:11:05 +00:00
|
|
|
return bio_alloc_bioset(bdev, nr_vecs, opf, gfp_mask, &fs_bio_set);
|
2012-09-06 22:35:01 +00:00
|
|
|
}
|
|
|
|
|
|
2021-10-12 11:12:24 +00:00
|
|
|
void submit_bio(struct bio *bio);
|
2016-11-01 13:40:12 +00:00
|
|
|
|
2015-07-20 13:29:37 +00:00
|
|
|
extern void bio_endio(struct bio *);
|
|
|
|
|
|
|
|
|
|
static inline void bio_io_error(struct bio *bio)
|
|
|
|
|
{
|
2017-06-03 07:38:06 +00:00
|
|
|
bio->bi_status = BLK_STS_IOERR;
|
2015-07-20 13:29:37 +00:00
|
|
|
bio_endio(bio);
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-20 12:05:46 +00:00
|
|
|
static inline void bio_wouldblock_error(struct bio *bio)
|
|
|
|
|
{
|
block: mark bio_wouldblock_error() bio with BIO_QUIET
We really don't care about triggering buffer errors for this condition.
This avoids a spew of:
Buffer I/O error on dev sdc, logical block 785929, async page read
Buffer I/O error on dev sdc, logical block 759095, async page read
Buffer I/O error on dev sdc, logical block 766922, async page read
Buffer I/O error on dev sdc, logical block 17659, async page read
Buffer I/O error on dev sdc, logical block 637571, async page read
Buffer I/O error on dev sdc, logical block 39241, async page read
Buffer I/O error on dev sdc, logical block 397241, async page read
Buffer I/O error on dev sdc, logical block 763992, async page read
from -EAGAIN conditions on request allocation for async reads.
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2020-06-01 16:02:01 +00:00
|
|
|
bio_set_flag(bio, BIO_QUIET);
|
2017-06-20 12:05:46 +00:00
|
|
|
bio->bi_status = BLK_STS_AGAIN;
|
2015-07-20 13:29:37 +00:00
|
|
|
bio_endio(bio);
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-09 16:03:02 +00:00
|
|
|
/*
|
|
|
|
|
* Calculate number of bvec segments that should be allocated to fit data
|
2021-01-09 16:03:03 +00:00
|
|
|
* pointed by @iter. If @iter is backed by bvec it's going to be reused
|
|
|
|
|
* instead of allocating a new one.
|
2021-01-09 16:03:02 +00:00
|
|
|
*/
|
|
|
|
|
static inline int bio_iov_vecs_to_alloc(struct iov_iter *iter, int max_segs)
|
|
|
|
|
{
|
2021-01-09 16:03:03 +00:00
|
|
|
if (iov_iter_is_bvec(iter))
|
|
|
|
|
return 0;
|
2021-01-09 16:03:02 +00:00
|
|
|
return iov_iter_npages(iter, max_segs);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct request_queue;
|
|
|
|
|
|
2016-06-05 19:31:41 +00:00
|
|
|
extern int submit_bio_wait(struct bio *bio);
|
2022-01-24 09:11:06 +00:00
|
|
|
void bio_init(struct bio *bio, struct block_device *bdev, struct bio_vec *table,
|
2022-07-14 18:06:32 +00:00
|
|
|
unsigned short max_vecs, blk_opf_t opf);
|
2017-06-28 21:30:13 +00:00
|
|
|
extern void bio_uninit(struct bio *);
|
2022-07-14 18:06:32 +00:00
|
|
|
void bio_reset(struct bio *bio, struct block_device *bdev, blk_opf_t opf);
|
2013-11-24 02:34:15 +00:00
|
|
|
void bio_chain(struct bio *, struct bio *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2023-05-31 11:50:40 +00:00
|
|
|
int __must_check bio_add_page(struct bio *bio, struct page *page, unsigned len,
|
|
|
|
|
unsigned off);
|
2023-05-31 11:50:43 +00:00
|
|
|
bool __must_check bio_add_folio(struct bio *bio, struct folio *folio,
|
|
|
|
|
size_t len, size_t off);
|
2005-11-11 11:30:27 +00:00
|
|
|
extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
|
|
|
|
|
unsigned int, unsigned int);
|
2021-02-04 10:21:40 +00:00
|
|
|
int bio_add_zone_append_page(struct bio *bio, struct page *page,
|
|
|
|
|
unsigned int len, unsigned int offset);
|
2018-06-01 16:03:05 +00:00
|
|
|
void __bio_add_page(struct bio *bio, struct page *page,
|
|
|
|
|
unsigned int len, unsigned int off);
|
2023-05-31 11:50:41 +00:00
|
|
|
void bio_add_folio_nofail(struct bio *bio, struct folio *folio, size_t len,
|
|
|
|
|
size_t off);
|
2016-10-31 17:59:24 +00:00
|
|
|
int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter);
|
2021-10-27 12:21:07 +00:00
|
|
|
void bio_iov_bvec_set(struct bio *bio, struct iov_iter *iter);
|
2021-10-19 21:24:14 +00:00
|
|
|
void __bio_release_pages(struct bio *bio, bool mark_dirty);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void bio_set_pages_dirty(struct bio *bio);
|
|
|
|
|
extern void bio_check_pages_dirty(struct bio *bio);
|
2009-11-26 08:16:19 +00:00
|
|
|
|
2023-01-04 21:43:27 +00:00
|
|
|
extern void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,
|
|
|
|
|
struct bio *src, struct bvec_iter *src_iter);
|
2012-09-10 20:57:51 +00:00
|
|
|
extern void bio_copy_data(struct bio *dst, struct bio *src);
|
2016-09-22 07:10:01 +00:00
|
|
|
extern void bio_free_pages(struct bio *bio);
|
2020-03-25 15:48:40 +00:00
|
|
|
void guard_bio_eod(struct bio *bio);
|
2023-08-13 18:26:36 +00:00
|
|
|
void zero_fill_bio_iter(struct bio *bio, struct bvec_iter iter);
|
|
|
|
|
|
|
|
|
|
static inline void zero_fill_bio(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
zero_fill_bio_iter(bio, bio->bi_iter);
|
|
|
|
|
}
|
2018-05-09 01:33:53 +00:00
|
|
|
|
2021-10-19 21:24:14 +00:00
|
|
|
static inline void bio_release_pages(struct bio *bio, bool mark_dirty)
|
|
|
|
|
{
|
2023-06-14 14:03:40 +00:00
|
|
|
if (bio_flagged(bio, BIO_PAGE_PINNED))
|
2021-10-19 21:24:14 +00:00
|
|
|
__bio_release_pages(bio, mark_dirty);
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-23 17:10:32 +00:00
|
|
|
#define bio_dev(bio) \
|
2021-01-24 10:02:34 +00:00
|
|
|
disk_devt((bio)->bi_bdev->bd_disk)
|
2017-08-23 17:10:32 +00:00
|
|
|
|
2012-03-05 21:15:27 +00:00
|
|
|
#ifdef CONFIG_BLK_CGROUP
|
2018-12-05 17:10:29 +00:00
|
|
|
void bio_associate_blkg(struct bio *bio);
|
2018-12-05 17:10:34 +00:00
|
|
|
void bio_associate_blkg_from_css(struct bio *bio,
|
|
|
|
|
struct cgroup_subsys_state *css);
|
2018-12-05 17:10:35 +00:00
|
|
|
void bio_clone_blkg_association(struct bio *dst, struct bio *src);
|
2023-03-27 00:49:51 +00:00
|
|
|
void blkcg_punt_bio_submit(struct bio *bio);
|
2012-03-05 21:15:27 +00:00
|
|
|
#else /* CONFIG_BLK_CGROUP */
|
2018-12-05 17:10:29 +00:00
|
|
|
static inline void bio_associate_blkg(struct bio *bio) { }
|
2018-12-05 17:10:34 +00:00
|
|
|
static inline void bio_associate_blkg_from_css(struct bio *bio,
|
|
|
|
|
struct cgroup_subsys_state *css)
|
|
|
|
|
{ }
|
2018-12-05 17:10:35 +00:00
|
|
|
static inline void bio_clone_blkg_association(struct bio *dst,
|
|
|
|
|
struct bio *src) { }
|
2023-03-27 00:49:51 +00:00
|
|
|
static inline void blkcg_punt_bio_submit(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
submit_bio(bio);
|
|
|
|
|
}
|
2012-03-05 21:15:27 +00:00
|
|
|
#endif /* CONFIG_BLK_CGROUP */
|
|
|
|
|
|
2021-10-19 21:24:10 +00:00
|
|
|
static inline void bio_set_dev(struct bio *bio, struct block_device *bdev)
|
|
|
|
|
{
|
|
|
|
|
bio_clear_flag(bio, BIO_REMAPPED);
|
|
|
|
|
if (bio->bi_bdev != bdev)
|
blk-throttle: fix that io throttle can only work for single bio
Test scripts:
cd /sys/fs/cgroup/blkio/
echo "8:0 1024" > blkio.throttle.write_bps_device
echo $$ > cgroup.procs
dd if=/dev/zero of=/dev/sda bs=10k count=1 oflag=direct &
dd if=/dev/zero of=/dev/sda bs=10k count=1 oflag=direct &
Test result:
10240 bytes (10 kB, 10 KiB) copied, 10.0134 s, 1.0 kB/s
10240 bytes (10 kB, 10 KiB) copied, 10.0135 s, 1.0 kB/s
The problem is that the second bio is finished after 10s instead of 20s.
Root cause:
1) second bio will be flagged:
__blk_throtl_bio
while (true) {
...
if (sq->nr_queued[rw]) -> some bio is throttled already
break
};
bio_set_flag(bio, BIO_THROTTLED); -> flag the bio
2) flagged bio will be dispatched without waiting:
throtl_dispatch_tg
tg_may_dispatch
tg_with_in_bps_limit
if (bps_limit == U64_MAX || bio_flagged(bio, BIO_THROTTLED))
*wait = 0; -> wait time is zero
return true;
commit 9f5ede3c01f9 ("block: throttle split bio in case of iops limit")
support to count split bios for iops limit, thus it adds flagged bio
checking in tg_with_in_bps_limit() so that split bios will only count
once for bps limit, however, it introduce a new problem that io throttle
won't work if multiple bios are throttled.
In order to fix the problem, handle iops/bps limit in different ways:
1) for iops limit, there is no flag to record if the bio is throttled,
and iops is always applied.
2) for bps limit, original bio will be flagged with BIO_BPS_THROTTLED,
and io throttle will ignore bio with the flag.
Noted this patch also remove the code to set flag in __bio_clone(), it's
introduced in commit 111be8839817 ("block-throttle: avoid double
charge"), and author thinks split bio can be resubmited and throttled
again, which is wrong because split bio will continue to dispatch from
caller.
Fixes: 9f5ede3c01f9 ("block: throttle split bio in case of iops limit")
Cc: <stable@vger.kernel.org>
Signed-off-by: Yu Kuai <yukuai3@huawei.com>
Acked-by: Tejun Heo <tj@kernel.org>
Link: https://lore.kernel.org/r/20220829022240.3348319-2-yukuai1@huaweicloud.com
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2022-08-29 02:22:37 +00:00
|
|
|
bio_clear_flag(bio, BIO_BPS_THROTTLED);
|
2021-10-19 21:24:10 +00:00
|
|
|
bio->bi_bdev = bdev;
|
|
|
|
|
bio_associate_blkg(bio);
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-07 17:55:13 +00:00
|
|
|
/*
|
2009-04-17 06:41:21 +00:00
|
|
|
* BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
|
2009-04-07 17:55:13 +00:00
|
|
|
*
|
|
|
|
|
* A bio_list anchors a singly-linked list of bios chained through the bi_next
|
|
|
|
|
* member of the bio. The bio_list also caches the last list member to allow
|
|
|
|
|
* fast access to the tail.
|
|
|
|
|
*/
|
|
|
|
|
struct bio_list {
|
|
|
|
|
struct bio *head;
|
|
|
|
|
struct bio *tail;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline int bio_list_empty(const struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
return bl->head == NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_list_init(struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
bl->head = bl->tail = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
blk-mq: new multi-queue block IO queueing mechanism
Linux currently has two models for block devices:
- The classic request_fn based approach, where drivers use struct
request units for IO. The block layer provides various helper
functionalities to let drivers share code, things like tag
management, timeout handling, queueing, etc.
- The "stacked" approach, where a driver squeezes in between the
block layer and IO submitter. Since this bypasses the IO stack,
driver generally have to manage everything themselves.
With drivers being written for new high IOPS devices, the classic
request_fn based driver doesn't work well enough. The design dates
back to when both SMP and high IOPS was rare. It has problems with
scaling to bigger machines, and runs into scaling issues even on
smaller machines when you have IOPS in the hundreds of thousands
per device.
The stacked approach is then most often selected as the model
for the driver. But this means that everybody has to re-invent
everything, and along with that we get all the problems again
that the shared approach solved.
This commit introduces blk-mq, block multi queue support. The
design is centered around per-cpu queues for queueing IO, which
then funnel down into x number of hardware submission queues.
We might have a 1:1 mapping between the two, or it might be
an N:M mapping. That all depends on what the hardware supports.
blk-mq provides various helper functions, which include:
- Scalable support for request tagging. Most devices need to
be able to uniquely identify a request both in the driver and
to the hardware. The tagging uses per-cpu caches for freed
tags, to enable cache hot reuse.
- Timeout handling without tracking request on a per-device
basis. Basically the driver should be able to get a notification,
if a request happens to fail.
- Optional support for non 1:1 mappings between issue and
submission queues. blk-mq can redirect IO completions to the
desired location.
- Support for per-request payloads. Drivers almost always need
to associate a request structure with some driver private
command structure. Drivers can tell blk-mq this at init time,
and then any request handed to the driver will have the
required size of memory associated with it.
- Support for merging of IO, and plugging. The stacked model
gets neither of these. Even for high IOPS devices, merging
sequential IO reduces per-command overhead and thus
increases bandwidth.
For now, this is provided as a potential 3rd queueing model, with
the hope being that, as it matures, it can replace both the classic
and stacked model. That would get us back to having just 1 real
model for block devices, leaving the stacked approach to dm/md
devices (as it was originally intended).
Contributions in this patch from the following people:
Shaohua Li <shli@fusionio.com>
Alexander Gordeev <agordeev@redhat.com>
Christoph Hellwig <hch@infradead.org>
Mike Christie <michaelc@cs.wisc.edu>
Matias Bjorling <m@bjorling.me>
Jeff Moyer <jmoyer@redhat.com>
Acked-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2013-10-24 08:20:05 +00:00
|
|
|
#define BIO_EMPTY_LIST { NULL, NULL }
|
|
|
|
|
|
2009-04-07 17:55:13 +00:00
|
|
|
#define bio_list_for_each(bio, bl) \
|
|
|
|
|
for (bio = (bl)->head; bio; bio = bio->bi_next)
|
|
|
|
|
|
|
|
|
|
static inline unsigned bio_list_size(const struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
unsigned sz = 0;
|
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
|
|
bio_list_for_each(bio, bl)
|
|
|
|
|
sz++;
|
|
|
|
|
|
|
|
|
|
return sz;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
bio->bi_next = NULL;
|
|
|
|
|
|
|
|
|
|
if (bl->tail)
|
|
|
|
|
bl->tail->bi_next = bio;
|
|
|
|
|
else
|
|
|
|
|
bl->head = bio;
|
|
|
|
|
|
|
|
|
|
bl->tail = bio;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
bio->bi_next = bl->head;
|
|
|
|
|
|
|
|
|
|
bl->head = bio;
|
|
|
|
|
|
|
|
|
|
if (!bl->tail)
|
|
|
|
|
bl->tail = bio;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
|
|
|
|
|
{
|
|
|
|
|
if (!bl2->head)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (bl->tail)
|
|
|
|
|
bl->tail->bi_next = bl2->head;
|
|
|
|
|
else
|
|
|
|
|
bl->head = bl2->head;
|
|
|
|
|
|
|
|
|
|
bl->tail = bl2->tail;
|
|
|
|
|
}
|
|
|
|
|
|
2024-03-28 08:41:44 +00:00
|
|
|
static inline void bio_list_merge_init(struct bio_list *bl,
|
|
|
|
|
struct bio_list *bl2)
|
|
|
|
|
{
|
|
|
|
|
bio_list_merge(bl, bl2);
|
|
|
|
|
bio_list_init(bl2);
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-07 17:55:13 +00:00
|
|
|
static inline void bio_list_merge_head(struct bio_list *bl,
|
|
|
|
|
struct bio_list *bl2)
|
|
|
|
|
{
|
|
|
|
|
if (!bl2->head)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (bl->head)
|
|
|
|
|
bl2->tail->bi_next = bl->head;
|
|
|
|
|
else
|
|
|
|
|
bl->tail = bl2->tail;
|
|
|
|
|
|
|
|
|
|
bl->head = bl2->head;
|
|
|
|
|
}
|
|
|
|
|
|
2009-06-10 04:38:40 +00:00
|
|
|
static inline struct bio *bio_list_peek(struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
return bl->head;
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-07 17:55:13 +00:00
|
|
|
static inline struct bio *bio_list_pop(struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
struct bio *bio = bl->head;
|
|
|
|
|
|
|
|
|
|
if (bio) {
|
|
|
|
|
bl->head = bl->head->bi_next;
|
|
|
|
|
if (!bl->head)
|
|
|
|
|
bl->tail = NULL;
|
|
|
|
|
|
|
|
|
|
bio->bi_next = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return bio;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct bio *bio_list_get(struct bio_list *bl)
|
|
|
|
|
{
|
|
|
|
|
struct bio *bio = bl->head;
|
|
|
|
|
|
|
|
|
|
bl->head = bl->tail = NULL;
|
|
|
|
|
|
|
|
|
|
return bio;
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-05 15:54:22 +00:00
|
|
|
/*
|
|
|
|
|
* Increment chain count for the bio. Make sure the CHAIN flag update
|
|
|
|
|
* is visible before the raised count.
|
|
|
|
|
*/
|
|
|
|
|
static inline void bio_inc_remaining(struct bio *bio)
|
|
|
|
|
{
|
|
|
|
|
bio_set_flag(bio, BIO_CHAIN);
|
|
|
|
|
smp_mb__before_atomic();
|
|
|
|
|
atomic_inc(&bio->__bi_remaining);
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-24 11:56:11 +00:00
|
|
|
/*
|
|
|
|
|
* bio_set is used to allow other portions of the IO system to
|
|
|
|
|
* allocate their own private memory pools for bio and iovec structures.
|
|
|
|
|
* These memory pools in turn all allocate from the bio_slab
|
|
|
|
|
* and the bvec_slabs[].
|
|
|
|
|
*/
|
|
|
|
|
#define BIO_POOL_SIZE 2
|
|
|
|
|
|
|
|
|
|
struct bio_set {
|
|
|
|
|
struct kmem_cache *bio_slab;
|
|
|
|
|
unsigned int front_pad;
|
|
|
|
|
|
2021-03-08 18:37:47 +00:00
|
|
|
/*
|
|
|
|
|
* per-cpu bio alloc cache
|
|
|
|
|
*/
|
|
|
|
|
struct bio_alloc_cache __percpu *cache;
|
|
|
|
|
|
2018-05-09 01:33:50 +00:00
|
|
|
mempool_t bio_pool;
|
|
|
|
|
mempool_t bvec_pool;
|
2012-08-24 11:56:11 +00:00
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
2018-05-09 01:33:50 +00:00
|
|
|
mempool_t bio_integrity_pool;
|
|
|
|
|
mempool_t bvec_integrity_pool;
|
2012-08-24 11:56:11 +00:00
|
|
|
#endif
|
block: Avoid deadlocks with bio allocation by stacking drivers
Previously, if we ever try to allocate more than once from the same bio
set while running under generic_make_request() (i.e. a stacking block
driver), we risk deadlock.
This is because of the code in generic_make_request() that converts
recursion to iteration; any bios we submit won't actually be submitted
(so they can complete and eventually be freed) until after we return -
this means if we allocate a second bio, we're blocking the first one
from ever being freed.
Thus if enough threads call into a stacking block driver at the same
time with bios that need multiple splits, and the bio_set's reserve gets
used up, we deadlock.
This can be worked around in the driver code - we could check if we're
running under generic_make_request(), then mask out __GFP_WAIT when we
go to allocate a bio, and if the allocation fails punt to workqueue and
retry the allocation.
But this is tricky and not a generic solution. This patch solves it for
all users by inverting the previously described technique. We allocate a
rescuer workqueue for each bio_set, and then in the allocation code if
there are bios on current->bio_list we would be blocking, we punt them
to the rescuer workqueue to be submitted.
This guarantees forward progress for bio allocations under
generic_make_request() provided each bio is submitted before allocating
the next, and provided the bios are freed after they complete.
Note that this doesn't do anything for allocation from other mempools.
Instead of allocating per bio data structures from a mempool, code
should use bio_set's front_pad.
Tested it by forcing the rescue codepath to be taken (by disabling the
first GFP_NOWAIT) attempt, and then ran it with bcache (which does a lot
of arbitrary bio splitting) and verified that the rescuer was being
invoked.
Signed-off-by: Kent Overstreet <koverstreet@google.com>
CC: Jens Axboe <axboe@kernel.dk>
Acked-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Muthukumar Ratty <muthur@gmail.com>
2012-09-10 21:33:46 +00:00
|
|
|
|
2021-01-11 03:05:54 +00:00
|
|
|
unsigned int back_pad;
|
block: Avoid deadlocks with bio allocation by stacking drivers
Previously, if we ever try to allocate more than once from the same bio
set while running under generic_make_request() (i.e. a stacking block
driver), we risk deadlock.
This is because of the code in generic_make_request() that converts
recursion to iteration; any bios we submit won't actually be submitted
(so they can complete and eventually be freed) until after we return -
this means if we allocate a second bio, we're blocking the first one
from ever being freed.
Thus if enough threads call into a stacking block driver at the same
time with bios that need multiple splits, and the bio_set's reserve gets
used up, we deadlock.
This can be worked around in the driver code - we could check if we're
running under generic_make_request(), then mask out __GFP_WAIT when we
go to allocate a bio, and if the allocation fails punt to workqueue and
retry the allocation.
But this is tricky and not a generic solution. This patch solves it for
all users by inverting the previously described technique. We allocate a
rescuer workqueue for each bio_set, and then in the allocation code if
there are bios on current->bio_list we would be blocking, we punt them
to the rescuer workqueue to be submitted.
This guarantees forward progress for bio allocations under
generic_make_request() provided each bio is submitted before allocating
the next, and provided the bios are freed after they complete.
Note that this doesn't do anything for allocation from other mempools.
Instead of allocating per bio data structures from a mempool, code
should use bio_set's front_pad.
Tested it by forcing the rescue codepath to be taken (by disabling the
first GFP_NOWAIT) attempt, and then ran it with bcache (which does a lot
of arbitrary bio splitting) and verified that the rescuer was being
invoked.
Signed-off-by: Kent Overstreet <koverstreet@google.com>
CC: Jens Axboe <axboe@kernel.dk>
Acked-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Muthukumar Ratty <muthur@gmail.com>
2012-09-10 21:33:46 +00:00
|
|
|
/*
|
|
|
|
|
* Deadlock avoidance for stacking block drivers: see comments in
|
|
|
|
|
* bio_alloc_bioset() for details
|
|
|
|
|
*/
|
|
|
|
|
spinlock_t rescue_lock;
|
|
|
|
|
struct bio_list rescue_list;
|
|
|
|
|
struct work_struct rescue_work;
|
|
|
|
|
struct workqueue_struct *rescue_workqueue;
|
2021-03-08 18:37:47 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Hot un-plug notifier for the per-cpu cache, if used
|
|
|
|
|
*/
|
|
|
|
|
struct hlist_node cpuhp_dead;
|
2012-08-24 11:56:11 +00:00
|
|
|
};
|
|
|
|
|
|
2018-05-20 22:25:47 +00:00
|
|
|
static inline bool bioset_initialized(struct bio_set *bs)
|
|
|
|
|
{
|
|
|
|
|
return bs->bio_slab != NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
#if defined(CONFIG_BLK_DEV_INTEGRITY)
|
|
|
|
|
|
2013-11-24 01:20:16 +00:00
|
|
|
#define bip_for_each_vec(bvl, bip, iter) \
|
|
|
|
|
for_each_bvec(bvl, (bip)->bip_vec, iter, (bip)->bip_iter)
|
2008-06-30 18:04:41 +00:00
|
|
|
|
2010-09-10 18:50:10 +00:00
|
|
|
#define bio_for_each_integrity_vec(_bvl, _bio, _iter) \
|
|
|
|
|
for_each_bio(_bio) \
|
|
|
|
|
bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)
|
|
|
|
|
|
2023-11-30 21:53:06 +00:00
|
|
|
int bio_integrity_map_user(struct bio *bio, void __user *ubuf, ssize_t len, u32 seed);
|
2008-06-30 18:04:41 +00:00
|
|
|
extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
|
|
|
|
|
extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
|
2017-06-29 18:31:11 +00:00
|
|
|
extern bool bio_integrity_prep(struct bio *);
|
2008-06-30 18:04:41 +00:00
|
|
|
extern void bio_integrity_advance(struct bio *, unsigned int);
|
2017-06-29 18:31:10 +00:00
|
|
|
extern void bio_integrity_trim(struct bio *);
|
2012-09-06 22:34:56 +00:00
|
|
|
extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
|
2009-06-26 13:37:49 +00:00
|
|
|
extern int bioset_integrity_create(struct bio_set *, int);
|
|
|
|
|
extern void bioset_integrity_free(struct bio_set *);
|
|
|
|
|
extern void bio_integrity_init(void);
|
2008-06-30 18:04:41 +00:00
|
|
|
|
|
|
|
|
#else /* CONFIG_BLK_DEV_INTEGRITY */
|
|
|
|
|
|
2014-09-26 23:20:08 +00:00
|
|
|
static inline void *bio_integrity(struct bio *bio)
|
2012-01-13 07:15:33 +00:00
|
|
|
{
|
2014-09-26 23:20:08 +00:00
|
|
|
return NULL;
|
2012-01-13 07:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int bioset_integrity_create(struct bio_set *bs, int pool_size)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bioset_integrity_free (struct bio_set *bs)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-29 18:31:11 +00:00
|
|
|
static inline bool bio_integrity_prep(struct bio *bio)
|
2012-01-13 07:15:33 +00:00
|
|
|
{
|
2017-06-29 18:31:11 +00:00
|
|
|
return true;
|
2012-01-13 07:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
2011-11-16 08:21:48 +00:00
|
|
|
static inline int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
|
2012-09-06 22:34:56 +00:00
|
|
|
gfp_t gfp_mask)
|
2011-11-16 08:21:48 +00:00
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2012-01-13 07:15:33 +00:00
|
|
|
|
|
|
|
|
static inline void bio_integrity_advance(struct bio *bio,
|
|
|
|
|
unsigned int bytes_done)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-29 18:31:10 +00:00
|
|
|
static inline void bio_integrity_trim(struct bio *bio)
|
2012-01-13 07:15:33 +00:00
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void bio_integrity_init(void)
|
|
|
|
|
{
|
|
|
|
|
return;
|
|
|
|
|
}
|
2008-06-30 18:04:41 +00:00
|
|
|
|
2014-09-26 23:20:08 +00:00
|
|
|
static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-03 16:32:21 +00:00
|
|
|
static inline void *bio_integrity_alloc(struct bio * bio, gfp_t gfp,
|
|
|
|
|
unsigned int nr)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int bio_integrity_add_page(struct bio *bio, struct page *page,
|
|
|
|
|
unsigned int len, unsigned int offset)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-30 21:53:06 +00:00
|
|
|
static inline int bio_integrity_map_user(struct bio *bio, void __user *ubuf,
|
|
|
|
|
ssize_t len, u32 seed)
|
|
|
|
|
{
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-30 18:04:41 +00:00
|
|
|
#endif /* CONFIG_BLK_DEV_INTEGRITY */
|
|
|
|
|
|
2018-12-21 16:10:46 +00:00
|
|
|
/*
|
|
|
|
|
* Mark a bio as polled. Note that for async polled IO, the caller must
|
|
|
|
|
* expect -EWOULDBLOCK if we cannot allocate a request (or other resources).
|
|
|
|
|
* We cannot block waiting for requests on polled IO, as those completions
|
|
|
|
|
* must be found by the caller. This is different than IRQ driven IO, where
|
|
|
|
|
* it's safe to wait for IO to complete.
|
|
|
|
|
*/
|
|
|
|
|
static inline void bio_set_polled(struct bio *bio, struct kiocb *kiocb)
|
|
|
|
|
{
|
2021-10-12 11:12:21 +00:00
|
|
|
bio->bi_opf |= REQ_POLLED;
|
2023-08-08 17:06:17 +00:00
|
|
|
if (kiocb->ki_flags & IOCB_NOWAIT)
|
2018-12-21 16:10:46 +00:00
|
|
|
bio->bi_opf |= REQ_NOWAIT;
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-24 20:35:25 +00:00
|
|
|
static inline void bio_clear_polled(struct bio *bio)
|
|
|
|
|
{
|
2022-12-16 15:20:31 +00:00
|
|
|
bio->bi_opf &= ~REQ_POLLED;
|
2022-03-24 20:35:25 +00:00
|
|
|
}
|
|
|
|
|
|
2022-01-24 09:11:02 +00:00
|
|
|
struct bio *blk_next_bio(struct bio *bio, struct block_device *bdev,
|
2022-07-14 18:06:32 +00:00
|
|
|
unsigned int nr_pages, blk_opf_t opf, gfp_t gfp);
|
2024-05-06 04:20:24 +00:00
|
|
|
struct bio *bio_chain_and_submit(struct bio *prev, struct bio *new);
|
2021-06-10 01:32:48 +00:00
|
|
|
|
2024-05-06 04:20:25 +00:00
|
|
|
struct bio *blk_alloc_discard_bio(struct block_device *bdev,
|
|
|
|
|
sector_t *sector, sector_t *nr_sects, gfp_t gfp_mask);
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* __LINUX_BIO_H */
|