2019-04-30 12:42:39 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2006-09-04 07:41:16 -06:00
|
|
|
* Copyright (C) 2001 Jens Axboe <axboe@kernel.dk>
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/blkdev.h>
|
2013-05-07 17:19:08 -06:00
|
|
|
#include <linux/uio.h>
|
2012-03-05 14:15:27 -07:00
|
|
|
#include <linux/iocontext.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
2011-11-16 21:57:37 -07:00
|
|
|
#include <linux/export.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/workqueue.h>
|
2012-03-05 14:15:27 -07:00
|
|
|
#include <linux/cgroup.h>
|
2018-07-03 09:14:50 -06:00
|
|
|
#include <linux/blk-cgroup.h>
|
2019-06-30 23:09:15 -06:00
|
|
|
#include <linux/highmem.h>
|
2020-03-17 21:43:36 -06:00
|
|
|
#include <linux/sched/sysctl.h>
|
block: Inline encryption support for blk-mq
We must have some way of letting a storage device driver know what
encryption context it should use for en/decrypting a request. However,
it's the upper layers (like the filesystem/fscrypt) that know about and
manages encryption contexts. As such, when the upper layer submits a bio
to the block layer, and this bio eventually reaches a device driver with
support for inline encryption, the device driver will need to have been
told the encryption context for that bio.
We want to communicate the encryption context from the upper layer to the
storage device along with the bio, when the bio is submitted to the block
layer. To do this, we add a struct bio_crypt_ctx to struct bio, which can
represent an encryption context (note that we can't use the bi_private
field in struct bio to do this because that field does not function to pass
information across layers in the storage stack). We also introduce various
functions to manipulate the bio_crypt_ctx and make the bio/request merging
logic aware of the bio_crypt_ctx.
We also make changes to blk-mq to make it handle bios with encryption
contexts. blk-mq can merge many bios into the same request. These bios need
to have contiguous data unit numbers (the necessary changes to blk-merge
are also made to ensure this) - as such, it suffices to keep the data unit
number of just the first bio, since that's all a storage driver needs to
infer the data unit number to use for each data block in each bio in a
request. blk-mq keeps track of the encryption context to be used for all
the bios in a request with the request's rq_crypt_ctx. When the first bio
is added to an empty request, blk-mq will program the encryption context
of that bio into the request_queue's keyslot manager, and store the
returned keyslot in the request's rq_crypt_ctx. All the functions to
operate on encryption contexts are in blk-crypto.c.
Upper layers only need to call bio_crypt_set_ctx with the encryption key,
algorithm and data_unit_num; they don't have to worry about getting a
keyslot for each encryption context, as blk-mq/blk-crypto handles that.
Blk-crypto also makes it possible for request-based layered devices like
dm-rq to make use of inline encryption hardware by cloning the
rq_crypt_ctx and programming a keyslot in the new request_queue when
necessary.
Note that any user of the block layer can submit bios with an
encryption context, such as filesystems, device-mapper targets, etc.
Signed-off-by: Satya Tangirala <satyat@google.com>
Reviewed-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2020-05-13 18:37:18 -06:00
|
|
|
#include <linux/blk-crypto.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
tracing/events: convert block trace points to TRACE_EVENT()
TRACE_EVENT is a more generic way to define tracepoints. Doing so adds
these new capabilities to this tracepoint:
- zero-copy and per-cpu splice() tracing
- binary tracing without printf overhead
- structured logging records exposed under /debug/tracing/events
- trace events embedded in function tracer output and other plugins
- user-defined, per tracepoint filter expressions
...
Cons:
- no dev_t info for the output of plug, unplug_timer and unplug_io events.
no dev_t info for getrq and sleeprq events if bio == NULL.
no dev_t info for rq_abort,...,rq_requeue events if rq->rq_disk == NULL.
This is mainly because we can't get the deivce from a request queue.
But this may change in the future.
- A packet command is converted to a string in TP_assign, not TP_print.
While blktrace do the convertion just before output.
Since pc requests should be rather rare, this is not a big issue.
- In blktrace, an event can have 2 different print formats, but a TRACE_EVENT
has a unique format, which means we have some unused data in a trace entry.
The overhead is minimized by using __dynamic_array() instead of __array().
I've benchmarked the ioctl blktrace vs the splice based TRACE_EVENT tracing:
dd dd + ioctl blktrace dd + TRACE_EVENT (splice)
1 7.36s, 42.7 MB/s 7.50s, 42.0 MB/s 7.41s, 42.5 MB/s
2 7.43s, 42.3 MB/s 7.48s, 42.1 MB/s 7.43s, 42.4 MB/s
3 7.38s, 42.6 MB/s 7.45s, 42.2 MB/s 7.41s, 42.5 MB/s
So the overhead of tracing is very small, and no regression when using
those trace events vs blktrace.
And the binary output of TRACE_EVENT is much smaller than blktrace:
# ls -l -h
-rw-r--r-- 1 root root 8.8M 06-09 13:24 sda.blktrace.0
-rw-r--r-- 1 root root 195K 06-09 13:24 sda.blktrace.1
-rw-r--r-- 1 root root 2.7M 06-09 13:25 trace_splice.out
Following are some comparisons between TRACE_EVENT and blktrace:
plug:
kjournald-480 [000] 303.084981: block_plug: [kjournald]
kjournald-480 [000] 303.084981: 8,0 P N [kjournald]
unplug_io:
kblockd/0-118 [000] 300.052973: block_unplug_io: [kblockd/0] 1
kblockd/0-118 [000] 300.052974: 8,0 U N [kblockd/0] 1
remap:
kjournald-480 [000] 303.085042: block_remap: 8,0 W 102736992 + 8 <- (8,8) 33384
kjournald-480 [000] 303.085043: 8,0 A W 102736992 + 8 <- (8,8) 33384
bio_backmerge:
kjournald-480 [000] 303.085086: block_bio_backmerge: 8,0 W 102737032 + 8 [kjournald]
kjournald-480 [000] 303.085086: 8,0 M W 102737032 + 8 [kjournald]
getrq:
kjournald-480 [000] 303.084974: block_getrq: 8,0 W 102736984 + 8 [kjournald]
kjournald-480 [000] 303.084975: 8,0 G W 102736984 + 8 [kjournald]
bash-2066 [001] 1072.953770: 8,0 G N [bash]
bash-2066 [001] 1072.953773: block_getrq: 0,0 N 0 + 0 [bash]
rq_complete:
konsole-2065 [001] 300.053184: block_rq_complete: 8,0 W () 103669040 + 16 [0]
konsole-2065 [001] 300.053191: 8,0 C W 103669040 + 16 [0]
ksoftirqd/1-7 [001] 1072.953811: 8,0 C N (5a 00 08 00 00 00 00 00 24 00) [0]
ksoftirqd/1-7 [001] 1072.953813: block_rq_complete: 0,0 N (5a 00 08 00 00 00 00 00 24 00) 0 + 0 [0]
rq_insert:
kjournald-480 [000] 303.084985: block_rq_insert: 8,0 W 0 () 102736984 + 8 [kjournald]
kjournald-480 [000] 303.084986: 8,0 I W 102736984 + 8 [kjournald]
Changelog from v2 -> v3:
- use the newly introduced __dynamic_array().
Changelog from v1 -> v2:
- use __string() instead of __array() to minimize the memory required
to store hex dump of rq->cmd().
- support large pc requests.
- add missing blk_fill_rwbs_rq() in block_rq_requeue TRACE_EVENT.
- some cleanups.
Signed-off-by: Li Zefan <lizf@cn.fujitsu.com>
LKML-Reference: <4A2DF669.5070905@cn.fujitsu.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2009-06-08 23:43:05 -06:00
|
|
|
#include <trace/events/block.h>
|
blk-throttle: add a simple idle detection
A cgroup gets assigned a low limit, but the cgroup could never dispatch
enough IO to cross the low limit. In such case, the queue state machine
will remain in LIMIT_LOW state and all other cgroups will be throttled
according to low limit. This is unfair for other cgroups. We should
treat the cgroup idle and upgrade the state machine to lower state.
We also have a downgrade logic. If the state machine upgrades because of
cgroup idle (real idle), the state machine will downgrade soon as the
cgroup is below its low limit. This isn't what we want. A more
complicated case is cgroup isn't idle when queue is in LIMIT_LOW. But
when queue gets upgraded to lower state, other cgroups could dispatch
more IO and this cgroup can't dispatch enough IO, so the cgroup is below
its low limit and looks like idle (fake idle). In this case, the queue
should downgrade soon. The key to determine if we should do downgrade is
to detect if cgroup is truely idle.
Unfortunately it's very hard to determine if a cgroup is real idle. This
patch uses the 'think time check' idea from CFQ for the purpose. Please
note, the idea doesn't work for all workloads. For example, a workload
with io depth 8 has disk utilization 100%, hence think time is 0, eg,
not idle. But the workload can run higher bandwidth with io depth 16.
Compared to io depth 16, the io depth 8 workload is idle. We use the
idea to roughly determine if a cgroup is idle.
We treat a cgroup idle if its think time is above a threshold (by
default 1ms for SSD and 100ms for HD). The idea is think time above the
threshold will start to harm performance. HD is much slower so a longer
think time is ok.
The patch (and the latter patches) uses 'unsigned long' to track time.
We convert 'ns' to 'us' with 'ns >> 10'. This is fast but loses
precision, should not a big deal.
Signed-off-by: Shaohua Li <shli@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2017-03-27 11:51:41 -06:00
|
|
|
#include "blk.h"
|
2018-07-03 09:15:00 -06:00
|
|
|
#include "blk-rq-qos.h"
|
2008-11-26 03:59:56 -07:00
|
|
|
|
2008-12-23 04:42:54 -07:00
|
|
|
/*
|
|
|
|
* Test patch to inline a certain number of bi_io_vec's inside the bio
|
|
|
|
* itself, to shrink a bio data allocation from two mempool calls to one
|
|
|
|
*/
|
|
|
|
#define BIO_INLINE_VECS 4
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* if you change this list, also change bvec_alloc or things will
|
|
|
|
* break badly! cannot be bigger than what you can fit into an
|
|
|
|
* unsigned short
|
|
|
|
*/
|
2018-03-21 10:49:29 -06:00
|
|
|
#define BV(x, n) { .nr_vecs = x, .name = "biovec-"#n }
|
2016-07-19 03:28:42 -06:00
|
|
|
static struct biovec_slab bvec_slabs[BVEC_POOL_NR] __read_mostly = {
|
2018-03-21 10:49:29 -06:00
|
|
|
BV(1, 1), BV(4, 4), BV(16, 16), BV(64, 64), BV(128, 128), BV(BIO_MAX_PAGES, max),
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
#undef BV
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fs_bio_set is the bio_set containing bio and iovec memory pools used by
|
|
|
|
* IO code that does not need private memory pools.
|
|
|
|
*/
|
2018-05-08 19:33:52 -06:00
|
|
|
struct bio_set fs_bio_set;
|
2012-09-06 16:35:01 -06:00
|
|
|
EXPORT_SYMBOL(fs_bio_set);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-12-10 07:35:05 -07:00
|
|
|
/*
|
|
|
|
* Our slab pool management
|
|
|
|
*/
|
|
|
|
struct bio_slab {
|
|
|
|
struct kmem_cache *slab;
|
|
|
|
unsigned int slab_ref;
|
|
|
|
unsigned int slab_size;
|
|
|
|
char name[8];
|
|
|
|
};
|
|
|
|
static DEFINE_MUTEX(bio_slab_lock);
|
|
|
|
static struct bio_slab *bio_slabs;
|
|
|
|
static unsigned int bio_slab_nr, bio_slab_max;
|
|
|
|
|
|
|
|
static struct kmem_cache *bio_find_or_create_slab(unsigned int extra_size)
|
|
|
|
{
|
|
|
|
unsigned int sz = sizeof(struct bio) + extra_size;
|
|
|
|
struct kmem_cache *slab = NULL;
|
2012-08-09 07:19:25 -06:00
|
|
|
struct bio_slab *bslab, *new_bio_slabs;
|
2012-10-22 13:53:36 -06:00
|
|
|
unsigned int new_bio_slab_max;
|
2008-12-10 07:35:05 -07:00
|
|
|
unsigned int i, entry = -1;
|
|
|
|
|
|
|
|
mutex_lock(&bio_slab_lock);
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
while (i < bio_slab_nr) {
|
2010-01-19 06:07:09 -07:00
|
|
|
bslab = &bio_slabs[i];
|
2008-12-10 07:35:05 -07:00
|
|
|
|
|
|
|
if (!bslab->slab && entry == -1)
|
|
|
|
entry = i;
|
|
|
|
else if (bslab->slab_size == sz) {
|
|
|
|
slab = bslab->slab;
|
|
|
|
bslab->slab_ref++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (slab)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
if (bio_slab_nr == bio_slab_max && entry == -1) {
|
2012-10-22 13:53:36 -06:00
|
|
|
new_bio_slab_max = bio_slab_max << 1;
|
2012-08-09 07:19:25 -06:00
|
|
|
new_bio_slabs = krealloc(bio_slabs,
|
2012-10-22 13:53:36 -06:00
|
|
|
new_bio_slab_max * sizeof(struct bio_slab),
|
2012-08-09 07:19:25 -06:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!new_bio_slabs)
|
2008-12-10 07:35:05 -07:00
|
|
|
goto out_unlock;
|
2012-10-22 13:53:36 -06:00
|
|
|
bio_slab_max = new_bio_slab_max;
|
2012-08-09 07:19:25 -06:00
|
|
|
bio_slabs = new_bio_slabs;
|
2008-12-10 07:35:05 -07:00
|
|
|
}
|
|
|
|
if (entry == -1)
|
|
|
|
entry = bio_slab_nr++;
|
|
|
|
|
|
|
|
bslab = &bio_slabs[entry];
|
|
|
|
|
|
|
|
snprintf(bslab->name, sizeof(bslab->name), "bio-%d", entry);
|
2014-03-28 13:51:55 -06:00
|
|
|
slab = kmem_cache_create(bslab->name, sz, ARCH_KMALLOC_MINALIGN,
|
|
|
|
SLAB_HWCACHE_ALIGN, NULL);
|
2008-12-10 07:35:05 -07:00
|
|
|
if (!slab)
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
bslab->slab = slab;
|
|
|
|
bslab->slab_ref = 1;
|
|
|
|
bslab->slab_size = sz;
|
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&bio_slab_lock);
|
|
|
|
return slab;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bio_put_slab(struct bio_set *bs)
|
|
|
|
{
|
|
|
|
struct bio_slab *bslab = NULL;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
mutex_lock(&bio_slab_lock);
|
|
|
|
|
|
|
|
for (i = 0; i < bio_slab_nr; i++) {
|
|
|
|
if (bs->bio_slab == bio_slabs[i].slab) {
|
|
|
|
bslab = &bio_slabs[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (WARN(!bslab, KERN_ERR "bio: unable to find slab!\n"))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
WARN_ON(!bslab->slab_ref);
|
|
|
|
|
|
|
|
if (--bslab->slab_ref)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
kmem_cache_destroy(bslab->slab);
|
|
|
|
bslab->slab = NULL;
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&bio_slab_lock);
|
|
|
|
}
|
|
|
|
|
2008-06-30 12:04:41 -06:00
|
|
|
unsigned int bvec_nr_vecs(unsigned short idx)
|
|
|
|
{
|
2018-08-08 13:27:53 -06:00
|
|
|
return bvec_slabs[--idx].nr_vecs;
|
2008-06-30 12:04:41 -06:00
|
|
|
}
|
|
|
|
|
2012-10-12 16:29:33 -06:00
|
|
|
void bvec_free(mempool_t *pool, struct bio_vec *bv, unsigned int idx)
|
2008-12-10 07:35:05 -07:00
|
|
|
{
|
2016-07-19 03:28:42 -06:00
|
|
|
if (!idx)
|
|
|
|
return;
|
|
|
|
idx--;
|
|
|
|
|
|
|
|
BIO_BUG_ON(idx >= BVEC_POOL_NR);
|
2008-12-10 07:35:05 -07:00
|
|
|
|
2016-07-19 03:28:42 -06:00
|
|
|
if (idx == BVEC_POOL_MAX) {
|
2012-10-12 16:29:33 -06:00
|
|
|
mempool_free(bv, pool);
|
2016-07-19 03:28:42 -06:00
|
|
|
} else {
|
2008-12-10 07:35:05 -07:00
|
|
|
struct biovec_slab *bvs = bvec_slabs + idx;
|
|
|
|
|
|
|
|
kmem_cache_free(bvs->slab, bv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-12 16:29:33 -06:00
|
|
|
struct bio_vec *bvec_alloc(gfp_t gfp_mask, int nr, unsigned long *idx,
|
|
|
|
mempool_t *pool)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct bio_vec *bvl;
|
|
|
|
|
2008-12-11 03:53:43 -07:00
|
|
|
/*
|
|
|
|
* see comment near bvec_array define!
|
|
|
|
*/
|
|
|
|
switch (nr) {
|
|
|
|
case 1:
|
|
|
|
*idx = 0;
|
|
|
|
break;
|
|
|
|
case 2 ... 4:
|
|
|
|
*idx = 1;
|
|
|
|
break;
|
|
|
|
case 5 ... 16:
|
|
|
|
*idx = 2;
|
|
|
|
break;
|
|
|
|
case 17 ... 64:
|
|
|
|
*idx = 3;
|
|
|
|
break;
|
|
|
|
case 65 ... 128:
|
|
|
|
*idx = 4;
|
|
|
|
break;
|
|
|
|
case 129 ... BIO_MAX_PAGES:
|
|
|
|
*idx = 5;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* idx now points to the pool we want to allocate from. only the
|
|
|
|
* 1-vec entry pool is mempool backed.
|
|
|
|
*/
|
2016-07-19 03:28:42 -06:00
|
|
|
if (*idx == BVEC_POOL_MAX) {
|
2008-12-11 03:53:43 -07:00
|
|
|
fallback:
|
2012-10-12 16:29:33 -06:00
|
|
|
bvl = mempool_alloc(pool, gfp_mask);
|
2008-12-11 03:53:43 -07:00
|
|
|
} else {
|
|
|
|
struct biovec_slab *bvs = bvec_slabs + *idx;
|
2015-11-06 17:28:21 -07:00
|
|
|
gfp_t __gfp_mask = gfp_mask & ~(__GFP_DIRECT_RECLAIM | __GFP_IO);
|
2008-12-11 03:53:43 -07:00
|
|
|
|
2008-09-11 05:17:37 -06:00
|
|
|
/*
|
2008-12-11 03:53:43 -07:00
|
|
|
* Make this allocation restricted and don't dump info on
|
|
|
|
* allocation failures, since we'll fallback to the mempool
|
|
|
|
* in case of failure.
|
2008-09-11 05:17:37 -06:00
|
|
|
*/
|
2008-12-11 03:53:43 -07:00
|
|
|
__gfp_mask |= __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-09-11 05:17:37 -06:00
|
|
|
/*
|
2015-11-06 17:28:21 -07:00
|
|
|
* Try a slab allocation. If this fails and __GFP_DIRECT_RECLAIM
|
2008-12-11 03:53:43 -07:00
|
|
|
* is set, retry with the 1-entry mempool
|
2008-09-11 05:17:37 -06:00
|
|
|
*/
|
2008-12-11 03:53:43 -07:00
|
|
|
bvl = kmem_cache_alloc(bvs->slab, __gfp_mask);
|
2015-11-06 17:28:21 -07:00
|
|
|
if (unlikely(!bvl && (gfp_mask & __GFP_DIRECT_RECLAIM))) {
|
2016-07-19 03:28:42 -06:00
|
|
|
*idx = BVEC_POOL_MAX;
|
2008-12-11 03:53:43 -07:00
|
|
|
goto fallback;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-19 03:28:42 -06:00
|
|
|
(*idx)++;
|
2005-04-16 16:20:36 -06:00
|
|
|
return bvl;
|
|
|
|
}
|
|
|
|
|
2017-06-28 15:30:13 -06:00
|
|
|
void bio_uninit(struct bio *bio)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2020-06-27 01:31:47 -06:00
|
|
|
#ifdef CONFIG_BLK_CGROUP
|
|
|
|
if (bio->bi_blkg) {
|
|
|
|
blkg_put(bio->bi_blkg);
|
|
|
|
bio->bi_blkg = NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2019-12-04 19:09:01 -07:00
|
|
|
if (bio_integrity(bio))
|
|
|
|
bio_integrity_free(bio);
|
block: Inline encryption support for blk-mq
We must have some way of letting a storage device driver know what
encryption context it should use for en/decrypting a request. However,
it's the upper layers (like the filesystem/fscrypt) that know about and
manages encryption contexts. As such, when the upper layer submits a bio
to the block layer, and this bio eventually reaches a device driver with
support for inline encryption, the device driver will need to have been
told the encryption context for that bio.
We want to communicate the encryption context from the upper layer to the
storage device along with the bio, when the bio is submitted to the block
layer. To do this, we add a struct bio_crypt_ctx to struct bio, which can
represent an encryption context (note that we can't use the bi_private
field in struct bio to do this because that field does not function to pass
information across layers in the storage stack). We also introduce various
functions to manipulate the bio_crypt_ctx and make the bio/request merging
logic aware of the bio_crypt_ctx.
We also make changes to blk-mq to make it handle bios with encryption
contexts. blk-mq can merge many bios into the same request. These bios need
to have contiguous data unit numbers (the necessary changes to blk-merge
are also made to ensure this) - as such, it suffices to keep the data unit
number of just the first bio, since that's all a storage driver needs to
infer the data unit number to use for each data block in each bio in a
request. blk-mq keeps track of the encryption context to be used for all
the bios in a request with the request's rq_crypt_ctx. When the first bio
is added to an empty request, blk-mq will program the encryption context
of that bio into the request_queue's keyslot manager, and store the
returned keyslot in the request's rq_crypt_ctx. All the functions to
operate on encryption contexts are in blk-crypto.c.
Upper layers only need to call bio_crypt_set_ctx with the encryption key,
algorithm and data_unit_num; they don't have to worry about getting a
keyslot for each encryption context, as blk-mq/blk-crypto handles that.
Blk-crypto also makes it possible for request-based layered devices like
dm-rq to make use of inline encryption hardware by cloning the
rq_crypt_ctx and programming a keyslot in the new request_queue when
necessary.
Note that any user of the block layer can submit bios with an
encryption context, such as filesystems, device-mapper targets, etc.
Signed-off-by: Satya Tangirala <satyat@google.com>
Reviewed-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2020-05-13 18:37:18 -06:00
|
|
|
|
|
|
|
bio_crypt_free_ctx(bio);
|
2012-09-06 16:35:00 -06:00
|
|
|
}
|
2017-06-28 15:30:13 -06:00
|
|
|
EXPORT_SYMBOL(bio_uninit);
|
2008-06-30 12:04:41 -06:00
|
|
|
|
2012-09-06 16:35:00 -06:00
|
|
|
static void bio_free(struct bio *bio)
|
|
|
|
{
|
|
|
|
struct bio_set *bs = bio->bi_pool;
|
|
|
|
void *p;
|
|
|
|
|
2017-06-28 15:30:13 -06:00
|
|
|
bio_uninit(bio);
|
2012-09-06 16:35:00 -06:00
|
|
|
|
|
|
|
if (bs) {
|
2018-05-08 19:33:50 -06:00
|
|
|
bvec_free(&bs->bvec_pool, bio->bi_io_vec, BVEC_POOL_IDX(bio));
|
2012-09-06 16:35:00 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have front padding, adjust the bio pointer before freeing
|
|
|
|
*/
|
|
|
|
p = bio;
|
2008-12-10 07:35:05 -07:00
|
|
|
p -= bs->front_pad;
|
|
|
|
|
2018-05-08 19:33:50 -06:00
|
|
|
mempool_free(p, &bs->bio_pool);
|
2012-09-06 16:35:00 -06:00
|
|
|
} else {
|
|
|
|
/* Bio was allocated by bio_kmalloc() */
|
|
|
|
kfree(bio);
|
|
|
|
}
|
2005-09-06 16:16:42 -06:00
|
|
|
}
|
|
|
|
|
2017-06-28 15:30:13 -06:00
|
|
|
/*
|
|
|
|
* Users of this function have their own bio allocation. Subsequently,
|
|
|
|
* they must remember to pair any call to bio_init() with bio_uninit()
|
|
|
|
* when IO has completed, or when the bio is released.
|
|
|
|
*/
|
2016-11-22 08:57:21 -07:00
|
|
|
void bio_init(struct bio *bio, struct bio_vec *table,
|
|
|
|
unsigned short max_vecs)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-18 05:14:03 -06:00
|
|
|
memset(bio, 0, sizeof(*bio));
|
2015-04-17 16:15:18 -06:00
|
|
|
atomic_set(&bio->__bi_remaining, 1);
|
2015-04-17 16:23:59 -06:00
|
|
|
atomic_set(&bio->__bi_cnt, 1);
|
2016-11-22 08:57:21 -07:00
|
|
|
|
|
|
|
bio->bi_io_vec = table;
|
|
|
|
bio->bi_max_vecs = max_vecs;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-09-26 08:19:21 -06:00
|
|
|
EXPORT_SYMBOL(bio_init);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-09-06 16:34:58 -06:00
|
|
|
/**
|
|
|
|
* bio_reset - reinitialize a bio
|
|
|
|
* @bio: bio to reset
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* After calling bio_reset(), @bio will be in the same state as a freshly
|
|
|
|
* allocated bio returned bio bio_alloc_bioset() - the only fields that are
|
|
|
|
* preserved are the ones that are initialized by bio_alloc_bioset(). See
|
|
|
|
* comment in struct bio.
|
|
|
|
*/
|
|
|
|
void bio_reset(struct bio *bio)
|
|
|
|
{
|
|
|
|
unsigned long flags = bio->bi_flags & (~0UL << BIO_RESET_BITS);
|
|
|
|
|
2017-06-28 15:30:13 -06:00
|
|
|
bio_uninit(bio);
|
2012-09-06 16:34:58 -06:00
|
|
|
|
|
|
|
memset(bio, 0, BIO_RESET_BYTES);
|
2015-07-20 07:29:37 -06:00
|
|
|
bio->bi_flags = flags;
|
2015-04-17 16:15:18 -06:00
|
|
|
atomic_set(&bio->__bi_remaining, 1);
|
2012-09-06 16:34:58 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bio_reset);
|
|
|
|
|
2016-03-11 09:34:51 -07:00
|
|
|
static struct bio *__bio_chain_endio(struct bio *bio)
|
2013-11-23 19:34:15 -07:00
|
|
|
{
|
2015-07-20 07:29:37 -06:00
|
|
|
struct bio *parent = bio->bi_private;
|
|
|
|
|
2017-06-03 01:38:06 -06:00
|
|
|
if (!parent->bi_status)
|
|
|
|
parent->bi_status = bio->bi_status;
|
2013-11-23 19:34:15 -07:00
|
|
|
bio_put(bio);
|
2016-03-11 09:34:51 -07:00
|
|
|
return parent;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bio_chain_endio(struct bio *bio)
|
|
|
|
{
|
|
|
|
bio_endio(__bio_chain_endio(bio));
|
2013-11-23 19:34:15 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* bio_chain - chain bio completions
|
2014-04-20 17:03:31 -06:00
|
|
|
* @bio: the target bio
|
2020-08-26 23:51:44 -06:00
|
|
|
* @parent: the parent bio of @bio
|
2013-11-23 19:34:15 -07:00
|
|
|
*
|
|
|
|
* The caller won't have a bi_end_io called when @bio completes - instead,
|
|
|
|
* @parent's bi_end_io won't be called until both @parent and @bio have
|
|
|
|
* completed; the chained bio will also be freed when it completes.
|
|
|
|
*
|
|
|
|
* The caller must not set bi_private or bi_end_io in @bio.
|
|
|
|
*/
|
|
|
|
void bio_chain(struct bio *bio, struct bio *parent)
|
|
|
|
{
|
|
|
|
BUG_ON(bio->bi_private || bio->bi_end_io);
|
|
|
|
|
|
|
|
bio->bi_private = parent;
|
|
|
|
bio->bi_end_io = bio_chain_endio;
|
2015-04-17 16:15:18 -06:00
|
|
|
bio_inc_remaining(parent);
|
2013-11-23 19:34:15 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bio_chain);
|
|
|
|
|
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 15:33:46 -06:00
|
|
|
static void bio_alloc_rescue(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct bio_set *bs = container_of(work, struct bio_set, rescue_work);
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
spin_lock(&bs->rescue_lock);
|
|
|
|
bio = bio_list_pop(&bs->rescue_list);
|
|
|
|
spin_unlock(&bs->rescue_lock);
|
|
|
|
|
|
|
|
if (!bio)
|
|
|
|
break;
|
|
|
|
|
2020-07-01 02:59:44 -06:00
|
|
|
submit_bio_noacct(bio);
|
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 15:33:46 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void punt_bios_to_rescuer(struct bio_set *bs)
|
|
|
|
{
|
|
|
|
struct bio_list punt, nopunt;
|
|
|
|
struct bio *bio;
|
|
|
|
|
2017-06-17 22:38:57 -06:00
|
|
|
if (WARN_ON_ONCE(!bs->rescue_workqueue))
|
|
|
|
return;
|
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 15:33:46 -06:00
|
|
|
/*
|
|
|
|
* In order to guarantee forward progress we must punt only bios that
|
|
|
|
* were allocated from this bio_set; otherwise, if there was a bio on
|
|
|
|
* there for a stacking driver higher up in the stack, processing it
|
|
|
|
* could require allocating bios from this bio_set, and doing that from
|
|
|
|
* our own rescuer would be bad.
|
|
|
|
*
|
|
|
|
* Since bio lists are singly linked, pop them all instead of trying to
|
|
|
|
* remove from the middle of the list:
|
|
|
|
*/
|
|
|
|
|
|
|
|
bio_list_init(&punt);
|
|
|
|
bio_list_init(&nopunt);
|
|
|
|
|
2017-03-09 23:00:47 -07:00
|
|
|
while ((bio = bio_list_pop(¤t->bio_list[0])))
|
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 15:33:46 -06:00
|
|
|
bio_list_add(bio->bi_pool == bs ? &punt : &nopunt, bio);
|
2017-03-09 23:00:47 -07:00
|
|
|
current->bio_list[0] = nopunt;
|
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 15:33:46 -06:00
|
|
|
|
2017-03-09 23:00:47 -07:00
|
|
|
bio_list_init(&nopunt);
|
|
|
|
while ((bio = bio_list_pop(¤t->bio_list[1])))
|
|
|
|
bio_list_add(bio->bi_pool == bs ? &punt : &nopunt, bio);
|
|
|
|
current->bio_list[1] = nopunt;
|
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 15:33:46 -06:00
|
|
|
|
|
|
|
spin_lock(&bs->rescue_lock);
|
|
|
|
bio_list_merge(&bs->rescue_list, &punt);
|
|
|
|
spin_unlock(&bs->rescue_lock);
|
|
|
|
|
|
|
|
queue_work(bs->rescue_workqueue, &bs->rescue_work);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* bio_alloc_bioset - allocate a bio for I/O
|
2017-10-16 12:01:00 -06:00
|
|
|
* @gfp_mask: the GFP_* mask given to the slab allocator
|
2005-04-16 16:20:36 -06:00
|
|
|
* @nr_iovecs: number of iovecs to pre-allocate
|
2010-01-15 03:05:07 -07:00
|
|
|
* @bs: the bio_set to allocate from.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Description:
|
2012-09-06 16:35:01 -06:00
|
|
|
* If @bs is NULL, uses kmalloc() to allocate the bio; else the allocation is
|
|
|
|
* backed by the @bs's mempool.
|
|
|
|
*
|
2015-11-06 17:28:21 -07:00
|
|
|
* When @bs is not NULL, if %__GFP_DIRECT_RECLAIM is set then bio_alloc will
|
|
|
|
* always be able to allocate a bio. This is due to the mempool guarantees.
|
|
|
|
* To make this work, callers must never allocate more than 1 bio at a time
|
|
|
|
* from this pool. Callers that need to allocate more than 1 bio must always
|
|
|
|
* submit the previously allocated bio for IO before attempting to allocate
|
|
|
|
* a new one. Failure to do so can cause deadlocks under memory pressure.
|
2012-09-06 16:35:01 -06:00
|
|
|
*
|
2020-07-01 02:59:44 -06:00
|
|
|
* Note that when running under submit_bio_noacct() (i.e. any block
|
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 15:33:46 -06:00
|
|
|
* driver), bios are not submitted until after you return - see the code in
|
2020-07-01 02:59:44 -06:00
|
|
|
* submit_bio_noacct() that converts recursion into iteration, to prevent
|
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 15:33:46 -06:00
|
|
|
* stack overflows.
|
|
|
|
*
|
|
|
|
* This would normally mean allocating multiple bios under
|
2020-07-01 02:59:44 -06:00
|
|
|
* submit_bio_noacct() would be susceptible to deadlocks, but we have
|
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 15:33:46 -06:00
|
|
|
* deadlock avoidance code that resubmits any blocked bios from a rescuer
|
|
|
|
* thread.
|
|
|
|
*
|
|
|
|
* However, we do not guarantee forward progress for allocations from other
|
|
|
|
* mempools. Doing multiple allocations from the same mempool under
|
2020-07-01 02:59:44 -06:00
|
|
|
* submit_bio_noacct() should be avoided - instead, use bio_set's front_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 15:33:46 -06:00
|
|
|
* for per bio allocations.
|
|
|
|
*
|
2012-09-06 16:35:01 -06:00
|
|
|
* RETURNS:
|
|
|
|
* Pointer to new bio on success, NULL on failure.
|
|
|
|
*/
|
2017-03-23 04:24:55 -06:00
|
|
|
struct bio *bio_alloc_bioset(gfp_t gfp_mask, unsigned int nr_iovecs,
|
|
|
|
struct bio_set *bs)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
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 15:33:46 -06:00
|
|
|
gfp_t saved_gfp = gfp_mask;
|
2012-09-06 16:35:01 -06:00
|
|
|
unsigned front_pad;
|
|
|
|
unsigned inline_vecs;
|
2009-02-21 03:16:36 -07:00
|
|
|
struct bio_vec *bvl = NULL;
|
2009-04-15 11:50:51 -06:00
|
|
|
struct bio *bio;
|
|
|
|
void *p;
|
|
|
|
|
2012-09-06 16:35:01 -06:00
|
|
|
if (!bs) {
|
|
|
|
if (nr_iovecs > UIO_MAXIOV)
|
|
|
|
return NULL;
|
|
|
|
|
2020-06-19 18:49:49 -06:00
|
|
|
p = kmalloc(struct_size(bio, bi_inline_vecs, nr_iovecs), gfp_mask);
|
2012-09-06 16:35:01 -06:00
|
|
|
front_pad = 0;
|
|
|
|
inline_vecs = nr_iovecs;
|
|
|
|
} else {
|
2014-10-03 15:27:12 -06:00
|
|
|
/* should not use nobvec bioset for nr_iovecs > 0 */
|
2018-05-08 19:33:50 -06:00
|
|
|
if (WARN_ON_ONCE(!mempool_initialized(&bs->bvec_pool) &&
|
|
|
|
nr_iovecs > 0))
|
2014-10-03 15:27:12 -06:00
|
|
|
return NULL;
|
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 15:33:46 -06:00
|
|
|
/*
|
2020-07-01 02:59:44 -06:00
|
|
|
* submit_bio_noacct() converts recursion to iteration; this
|
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 15:33:46 -06:00
|
|
|
* means if we're running beneath it, any bios we allocate and
|
|
|
|
* submit will not be submitted (and thus freed) until after we
|
|
|
|
* return.
|
|
|
|
*
|
|
|
|
* This exposes us to a potential deadlock if we allocate
|
|
|
|
* multiple bios from the same bio_set() while running
|
2020-07-01 02:59:44 -06:00
|
|
|
* underneath submit_bio_noacct(). If we were to allocate
|
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 15:33:46 -06:00
|
|
|
* multiple bios (say a stacking block driver that was splitting
|
|
|
|
* bios), we would deadlock if we exhausted the mempool's
|
|
|
|
* reserve.
|
|
|
|
*
|
|
|
|
* We solve this, and guarantee forward progress, with a rescuer
|
|
|
|
* workqueue per bio_set. If we go to allocate and there are
|
|
|
|
* bios on current->bio_list, we first try the allocation
|
2015-11-06 17:28:21 -07:00
|
|
|
* without __GFP_DIRECT_RECLAIM; if that fails, we punt those
|
|
|
|
* bios we would be blocking to the rescuer workqueue before
|
|
|
|
* we retry with the original gfp_flags.
|
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 15:33:46 -06:00
|
|
|
*/
|
|
|
|
|
2017-03-09 23:00:47 -07:00
|
|
|
if (current->bio_list &&
|
|
|
|
(!bio_list_empty(¤t->bio_list[0]) ||
|
2017-06-17 22:38:57 -06:00
|
|
|
!bio_list_empty(¤t->bio_list[1])) &&
|
|
|
|
bs->rescue_workqueue)
|
2015-11-06 17:28:21 -07:00
|
|
|
gfp_mask &= ~__GFP_DIRECT_RECLAIM;
|
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 15:33:46 -06:00
|
|
|
|
2018-05-08 19:33:50 -06:00
|
|
|
p = mempool_alloc(&bs->bio_pool, gfp_mask);
|
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 15:33:46 -06:00
|
|
|
if (!p && gfp_mask != saved_gfp) {
|
|
|
|
punt_bios_to_rescuer(bs);
|
|
|
|
gfp_mask = saved_gfp;
|
2018-05-08 19:33:50 -06:00
|
|
|
p = mempool_alloc(&bs->bio_pool, gfp_mask);
|
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 15:33:46 -06:00
|
|
|
}
|
|
|
|
|
2012-09-06 16:35:01 -06:00
|
|
|
front_pad = bs->front_pad;
|
|
|
|
inline_vecs = BIO_INLINE_VECS;
|
|
|
|
}
|
|
|
|
|
2009-04-15 11:50:51 -06:00
|
|
|
if (unlikely(!p))
|
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-09-06 16:35:01 -06:00
|
|
|
bio = p + front_pad;
|
2016-11-22 08:57:21 -07:00
|
|
|
bio_init(bio, NULL, 0);
|
2009-02-21 03:16:36 -07:00
|
|
|
|
2012-09-06 16:35:01 -06:00
|
|
|
if (nr_iovecs > inline_vecs) {
|
2016-07-19 03:28:42 -06:00
|
|
|
unsigned long idx = 0;
|
|
|
|
|
2018-05-08 19:33:50 -06:00
|
|
|
bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, &bs->bvec_pool);
|
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 15:33:46 -06:00
|
|
|
if (!bvl && gfp_mask != saved_gfp) {
|
|
|
|
punt_bios_to_rescuer(bs);
|
|
|
|
gfp_mask = saved_gfp;
|
2018-05-08 19:33:50 -06:00
|
|
|
bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx, &bs->bvec_pool);
|
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 15:33:46 -06:00
|
|
|
}
|
|
|
|
|
2009-02-21 03:16:36 -07:00
|
|
|
if (unlikely(!bvl))
|
|
|
|
goto err_free;
|
2012-05-25 14:03:11 -06:00
|
|
|
|
2016-07-19 03:28:42 -06:00
|
|
|
bio->bi_flags |= idx << BVEC_POOL_OFFSET;
|
2012-09-06 16:35:01 -06:00
|
|
|
} else if (nr_iovecs) {
|
|
|
|
bvl = bio->bi_inline_vecs;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2012-09-06 16:35:01 -06:00
|
|
|
|
|
|
|
bio->bi_pool = bs;
|
2009-02-21 03:16:36 -07:00
|
|
|
bio->bi_max_vecs = nr_iovecs;
|
|
|
|
bio->bi_io_vec = bvl;
|
2005-04-16 16:20:36 -06:00
|
|
|
return bio;
|
2009-02-21 03:16:36 -07:00
|
|
|
|
|
|
|
err_free:
|
2018-05-08 19:33:50 -06:00
|
|
|
mempool_free(p, &bs->bio_pool);
|
2009-02-21 03:16:36 -07:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-09-26 08:19:21 -06:00
|
|
|
EXPORT_SYMBOL(bio_alloc_bioset);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-05-08 19:33:53 -06:00
|
|
|
void zero_fill_bio_iter(struct bio *bio, struct bvec_iter start)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2013-11-23 18:19:00 -07:00
|
|
|
struct bio_vec bv;
|
|
|
|
struct bvec_iter iter;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-05-08 19:33:53 -06:00
|
|
|
__bio_for_each_segment(bv, bio, iter, start) {
|
2013-11-23 18:19:00 -07:00
|
|
|
char *data = bvec_kmap_irq(&bv, &flags);
|
|
|
|
memset(data, 0, bv.bv_len);
|
|
|
|
flush_dcache_page(bv.bv_page);
|
2005-04-16 16:20:36 -06:00
|
|
|
bvec_kunmap_irq(data, &flags);
|
|
|
|
}
|
|
|
|
}
|
2018-05-08 19:33:53 -06:00
|
|
|
EXPORT_SYMBOL(zero_fill_bio_iter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2020-01-04 18:41:14 -07:00
|
|
|
/**
|
|
|
|
* bio_truncate - truncate the bio to small size of @new_size
|
|
|
|
* @bio: the bio to be truncated
|
|
|
|
* @new_size: new size for truncating the bio
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Truncate the bio to new size of @new_size. If bio_op(bio) is
|
|
|
|
* REQ_OP_READ, zero the truncated part. This function should only
|
|
|
|
* be used for handling corner cases, such as bio eod.
|
|
|
|
*/
|
2019-12-27 16:05:48 -07:00
|
|
|
void bio_truncate(struct bio *bio, unsigned new_size)
|
|
|
|
{
|
|
|
|
struct bio_vec bv;
|
|
|
|
struct bvec_iter iter;
|
|
|
|
unsigned int done = 0;
|
|
|
|
bool truncated = false;
|
|
|
|
|
|
|
|
if (new_size >= bio->bi_iter.bi_size)
|
|
|
|
return;
|
|
|
|
|
2020-01-04 18:41:14 -07:00
|
|
|
if (bio_op(bio) != REQ_OP_READ)
|
2019-12-27 16:05:48 -07:00
|
|
|
goto exit;
|
|
|
|
|
|
|
|
bio_for_each_segment(bv, bio, iter) {
|
|
|
|
if (done + bv.bv_len > new_size) {
|
|
|
|
unsigned offset;
|
|
|
|
|
|
|
|
if (!truncated)
|
|
|
|
offset = new_size - done;
|
|
|
|
else
|
|
|
|
offset = 0;
|
|
|
|
zero_user(bv.bv_page, offset, bv.bv_len - offset);
|
|
|
|
truncated = true;
|
|
|
|
}
|
|
|
|
done += bv.bv_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
|
|
|
/*
|
|
|
|
* Don't touch bvec table here and make it really immutable, since
|
|
|
|
* fs bio user has to retrieve all pages via bio_for_each_segment_all
|
|
|
|
* in its .end_bio() callback.
|
|
|
|
*
|
|
|
|
* It is enough to truncate bio by updating .bi_size since we can make
|
|
|
|
* correct bvec with the updated .bi_size for drivers.
|
|
|
|
*/
|
|
|
|
bio->bi_iter.bi_size = new_size;
|
|
|
|
}
|
|
|
|
|
2020-03-25 09:48:40 -06:00
|
|
|
/**
|
|
|
|
* guard_bio_eod - truncate a BIO to fit the block device
|
|
|
|
* @bio: bio to truncate
|
|
|
|
*
|
|
|
|
* This allows us to do IO even on the odd last sectors of a device, even if the
|
|
|
|
* block size is some multiple of the physical sector size.
|
|
|
|
*
|
|
|
|
* We'll just truncate the bio to the size of the device, and clear the end of
|
|
|
|
* the buffer head manually. Truly out-of-range accesses will turn into actual
|
|
|
|
* I/O errors, this only handles the "we need to be able to do I/O at the final
|
|
|
|
* sector" case.
|
|
|
|
*/
|
|
|
|
void guard_bio_eod(struct bio *bio)
|
|
|
|
{
|
|
|
|
sector_t maxsector;
|
|
|
|
struct hd_struct *part;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
part = __disk_get_part(bio->bi_disk, bio->bi_partno);
|
|
|
|
if (part)
|
|
|
|
maxsector = part_nr_sects_read(part);
|
|
|
|
else
|
|
|
|
maxsector = get_capacity(bio->bi_disk);
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
if (!maxsector)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the *whole* IO is past the end of the device,
|
|
|
|
* let it through, and the IO layer will turn it into
|
|
|
|
* an EIO.
|
|
|
|
*/
|
|
|
|
if (unlikely(bio->bi_iter.bi_sector >= maxsector))
|
|
|
|
return;
|
|
|
|
|
|
|
|
maxsector -= bio->bi_iter.bi_sector;
|
|
|
|
if (likely((bio->bi_iter.bi_size >> 9) <= maxsector))
|
|
|
|
return;
|
|
|
|
|
|
|
|
bio_truncate(bio, maxsector << 9);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* bio_put - release a reference to a bio
|
|
|
|
* @bio: bio to release reference to
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Put a reference to a &struct bio, either one you have gotten with
|
2017-06-17 22:38:59 -06:00
|
|
|
* bio_alloc, bio_get or bio_clone_*. The last put of a bio will free it.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
|
|
|
void bio_put(struct bio *bio)
|
|
|
|
{
|
2015-04-17 16:23:59 -06:00
|
|
|
if (!bio_flagged(bio, BIO_REFFED))
|
2012-09-06 16:35:00 -06:00
|
|
|
bio_free(bio);
|
2015-04-17 16:23:59 -06:00
|
|
|
else {
|
|
|
|
BIO_BUG_ON(!atomic_read(&bio->__bi_cnt));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* last put frees it
|
|
|
|
*/
|
|
|
|
if (atomic_dec_and_test(&bio->__bi_cnt))
|
|
|
|
bio_free(bio);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-09-26 08:19:21 -06:00
|
|
|
EXPORT_SYMBOL(bio_put);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-11-23 19:19:27 -07:00
|
|
|
/**
|
|
|
|
* __bio_clone_fast - clone a bio that shares the original bio's biovec
|
|
|
|
* @bio: destination bio
|
|
|
|
* @bio_src: bio to clone
|
|
|
|
*
|
|
|
|
* Clone a &bio. Caller will own the returned bio, but not
|
|
|
|
* the actual data it points to. Reference count of returned
|
|
|
|
* bio will be one.
|
|
|
|
*
|
|
|
|
* Caller must ensure that @bio_src is not freed before @bio.
|
|
|
|
*/
|
|
|
|
void __bio_clone_fast(struct bio *bio, struct bio *bio_src)
|
|
|
|
{
|
2016-07-19 03:28:42 -06:00
|
|
|
BUG_ON(bio->bi_pool && BVEC_POOL_IDX(bio));
|
2013-11-23 19:19:27 -07:00
|
|
|
|
|
|
|
/*
|
2017-08-23 11:10:32 -06:00
|
|
|
* most users will be overriding ->bi_disk with a new target,
|
2013-11-23 19:19:27 -07:00
|
|
|
* so we don't set nor calculate new physical/hw segment counts here
|
|
|
|
*/
|
2017-08-23 11:10:32 -06:00
|
|
|
bio->bi_disk = bio_src->bi_disk;
|
2017-11-17 00:47:25 -07:00
|
|
|
bio->bi_partno = bio_src->bi_partno;
|
2015-07-24 12:37:59 -06:00
|
|
|
bio_set_flag(bio, BIO_CLONED);
|
2017-12-20 11:10:17 -07:00
|
|
|
if (bio_flagged(bio_src, BIO_THROTTLED))
|
|
|
|
bio_set_flag(bio, BIO_THROTTLED);
|
2016-08-05 15:35:16 -06:00
|
|
|
bio->bi_opf = bio_src->bi_opf;
|
2018-11-12 10:35:25 -07:00
|
|
|
bio->bi_ioprio = bio_src->bi_ioprio;
|
2017-06-27 09:22:02 -06:00
|
|
|
bio->bi_write_hint = bio_src->bi_write_hint;
|
2013-11-23 19:19:27 -07:00
|
|
|
bio->bi_iter = bio_src->bi_iter;
|
|
|
|
bio->bi_io_vec = bio_src->bi_io_vec;
|
2016-07-26 23:22:05 -06:00
|
|
|
|
2018-12-05 10:10:35 -07:00
|
|
|
bio_clone_blkg_association(bio, bio_src);
|
2018-12-05 10:10:32 -07:00
|
|
|
blkcg_bio_issue_init(bio);
|
2013-11-23 19:19:27 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__bio_clone_fast);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* bio_clone_fast - clone a bio that shares the original bio's biovec
|
|
|
|
* @bio: bio to clone
|
|
|
|
* @gfp_mask: allocation priority
|
|
|
|
* @bs: bio_set to allocate from
|
|
|
|
*
|
|
|
|
* Like __bio_clone_fast, only also allocates the returned bio
|
|
|
|
*/
|
|
|
|
struct bio *bio_clone_fast(struct bio *bio, gfp_t gfp_mask, struct bio_set *bs)
|
|
|
|
{
|
|
|
|
struct bio *b;
|
|
|
|
|
|
|
|
b = bio_alloc_bioset(gfp_mask, 0, bs);
|
|
|
|
if (!b)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
__bio_clone_fast(b, bio);
|
|
|
|
|
2020-09-15 21:53:13 -06:00
|
|
|
if (bio_crypt_clone(b, bio, gfp_mask) < 0)
|
|
|
|
goto err_put;
|
block: Inline encryption support for blk-mq
We must have some way of letting a storage device driver know what
encryption context it should use for en/decrypting a request. However,
it's the upper layers (like the filesystem/fscrypt) that know about and
manages encryption contexts. As such, when the upper layer submits a bio
to the block layer, and this bio eventually reaches a device driver with
support for inline encryption, the device driver will need to have been
told the encryption context for that bio.
We want to communicate the encryption context from the upper layer to the
storage device along with the bio, when the bio is submitted to the block
layer. To do this, we add a struct bio_crypt_ctx to struct bio, which can
represent an encryption context (note that we can't use the bi_private
field in struct bio to do this because that field does not function to pass
information across layers in the storage stack). We also introduce various
functions to manipulate the bio_crypt_ctx and make the bio/request merging
logic aware of the bio_crypt_ctx.
We also make changes to blk-mq to make it handle bios with encryption
contexts. blk-mq can merge many bios into the same request. These bios need
to have contiguous data unit numbers (the necessary changes to blk-merge
are also made to ensure this) - as such, it suffices to keep the data unit
number of just the first bio, since that's all a storage driver needs to
infer the data unit number to use for each data block in each bio in a
request. blk-mq keeps track of the encryption context to be used for all
the bios in a request with the request's rq_crypt_ctx. When the first bio
is added to an empty request, blk-mq will program the encryption context
of that bio into the request_queue's keyslot manager, and store the
returned keyslot in the request's rq_crypt_ctx. All the functions to
operate on encryption contexts are in blk-crypto.c.
Upper layers only need to call bio_crypt_set_ctx with the encryption key,
algorithm and data_unit_num; they don't have to worry about getting a
keyslot for each encryption context, as blk-mq/blk-crypto handles that.
Blk-crypto also makes it possible for request-based layered devices like
dm-rq to make use of inline encryption hardware by cloning the
rq_crypt_ctx and programming a keyslot in the new request_queue when
necessary.
Note that any user of the block layer can submit bios with an
encryption context, such as filesystems, device-mapper targets, etc.
Signed-off-by: Satya Tangirala <satyat@google.com>
Reviewed-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2020-05-13 18:37:18 -06:00
|
|
|
|
2020-09-15 21:53:13 -06:00
|
|
|
if (bio_integrity(bio) &&
|
|
|
|
bio_integrity_clone(b, bio, gfp_mask) < 0)
|
|
|
|
goto err_put;
|
2013-11-23 19:19:27 -07:00
|
|
|
|
|
|
|
return b;
|
2020-09-15 21:53:13 -06:00
|
|
|
|
|
|
|
err_put:
|
|
|
|
bio_put(b);
|
|
|
|
return NULL;
|
2013-11-23 19:19:27 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bio_clone_fast);
|
|
|
|
|
2020-03-24 01:25:12 -06:00
|
|
|
const char *bio_devname(struct bio *bio, char *buf)
|
|
|
|
{
|
|
|
|
return disk_name(bio->bi_disk, bio->bi_partno, buf);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bio_devname);
|
|
|
|
|
2019-03-17 04:01:07 -06:00
|
|
|
static inline bool page_is_mergeable(const struct bio_vec *bv,
|
|
|
|
struct page *page, unsigned int len, unsigned int off,
|
2019-06-17 03:14:11 -06:00
|
|
|
bool *same_page)
|
2019-03-17 04:01:07 -06:00
|
|
|
{
|
2020-08-17 13:52:06 -06:00
|
|
|
size_t bv_end = bv->bv_offset + bv->bv_len;
|
|
|
|
phys_addr_t vec_end_addr = page_to_phys(bv->bv_page) + bv_end - 1;
|
2019-03-17 04:01:07 -06:00
|
|
|
phys_addr_t page_addr = page_to_phys(page);
|
|
|
|
|
|
|
|
if (vec_end_addr + 1 != page_addr + off)
|
|
|
|
return false;
|
|
|
|
if (xen_domain() && !xen_biovec_phys_mergeable(bv, page))
|
|
|
|
return false;
|
2019-04-11 00:23:31 -06:00
|
|
|
|
2019-06-17 03:14:11 -06:00
|
|
|
*same_page = ((vec_end_addr & PAGE_MASK) == page_addr);
|
2020-08-17 13:52:06 -06:00
|
|
|
if (*same_page)
|
|
|
|
return true;
|
|
|
|
return (bv->bv_page + bv_end / PAGE_SIZE) == (page + off / PAGE_SIZE);
|
2019-03-17 04:01:07 -06:00
|
|
|
}
|
|
|
|
|
2020-05-12 02:55:46 -06:00
|
|
|
/*
|
|
|
|
* Try to merge a page into a segment, while obeying the hardware segment
|
|
|
|
* size limit. This is not for normal read/write bios, but for passthrough
|
|
|
|
* or Zone Append operations that we can't split.
|
|
|
|
*/
|
|
|
|
static bool bio_try_merge_hw_seg(struct request_queue *q, struct bio *bio,
|
|
|
|
struct page *page, unsigned len,
|
|
|
|
unsigned offset, bool *same_page)
|
2019-03-29 01:08:00 -06:00
|
|
|
{
|
2019-08-12 09:39:57 -06:00
|
|
|
struct bio_vec *bv = &bio->bi_io_vec[bio->bi_vcnt - 1];
|
2019-03-29 01:08:00 -06:00
|
|
|
unsigned long mask = queue_segment_boundary(q);
|
|
|
|
phys_addr_t addr1 = page_to_phys(bv->bv_page) + bv->bv_offset;
|
|
|
|
phys_addr_t addr2 = page_to_phys(page) + offset + len - 1;
|
|
|
|
|
|
|
|
if ((addr1 | mask) != (addr2 | mask))
|
|
|
|
return false;
|
|
|
|
if (bv->bv_len + len > queue_max_segment_size(q))
|
|
|
|
return false;
|
2019-08-12 09:39:57 -06:00
|
|
|
return __bio_try_merge_page(bio, page, len, offset, same_page);
|
2019-03-29 01:08:00 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2020-05-12 02:55:46 -06:00
|
|
|
* bio_add_hw_page - attempt to add a page to a bio with hw constraints
|
|
|
|
* @q: the target queue
|
|
|
|
* @bio: destination bio
|
|
|
|
* @page: page to add
|
|
|
|
* @len: vec entry length
|
|
|
|
* @offset: vec entry offset
|
|
|
|
* @max_sectors: maximum number of sectors that can be added
|
|
|
|
* @same_page: return if the segment has been merged inside the same page
|
2013-11-23 23:30:22 -07:00
|
|
|
*
|
2020-05-12 02:55:46 -06:00
|
|
|
* Add a page to a bio while respecting the hardware max_sectors, max_segment
|
|
|
|
* and gap limitations.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2020-05-12 02:55:46 -06:00
|
|
|
int bio_add_hw_page(struct request_queue *q, struct bio *bio,
|
2019-03-17 04:01:08 -06:00
|
|
|
struct page *page, unsigned int len, unsigned int offset,
|
2020-05-12 02:55:46 -06:00
|
|
|
unsigned int max_sectors, bool *same_page)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct bio_vec *bvec;
|
|
|
|
|
2020-05-12 02:55:46 -06:00
|
|
|
if (WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED)))
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2020-05-12 02:55:46 -06:00
|
|
|
if (((bio->bi_iter.bi_size + len) >> 9) > max_sectors)
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2006-01-06 01:43:28 -07:00
|
|
|
if (bio->bi_vcnt > 0) {
|
2020-05-12 02:55:46 -06:00
|
|
|
if (bio_try_merge_hw_seg(q, bio, page, len, offset, same_page))
|
2019-08-12 09:39:57 -06:00
|
|
|
return len;
|
2019-08-12 09:39:56 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the queue doesn't support SG gaps and adding this segment
|
|
|
|
* would create a gap, disallow it.
|
|
|
|
*/
|
2019-08-12 09:39:57 -06:00
|
|
|
bvec = &bio->bi_io_vec[bio->bi_vcnt - 1];
|
2019-08-12 09:39:56 -06:00
|
|
|
if (bvec_gap_to_prev(q, bvec, offset))
|
|
|
|
return 0;
|
2006-01-06 01:43:28 -07:00
|
|
|
}
|
|
|
|
|
2019-07-01 01:14:46 -06:00
|
|
|
if (bio_full(bio, len))
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2019-06-06 04:29:01 -06:00
|
|
|
if (bio->bi_vcnt >= queue_max_segments(q))
|
2019-03-29 01:08:00 -06:00
|
|
|
return 0;
|
|
|
|
|
2014-12-10 15:16:53 -07:00
|
|
|
bvec = &bio->bi_io_vec[bio->bi_vcnt];
|
|
|
|
bvec->bv_page = page;
|
|
|
|
bvec->bv_len = len;
|
|
|
|
bvec->bv_offset = offset;
|
|
|
|
bio->bi_vcnt++;
|
2019-04-25 01:04:35 -06:00
|
|
|
bio->bi_iter.bi_size += len;
|
2005-04-16 16:20:36 -06:00
|
|
|
return len;
|
|
|
|
}
|
2019-03-17 04:01:08 -06:00
|
|
|
|
2020-05-12 02:55:46 -06:00
|
|
|
/**
|
|
|
|
* bio_add_pc_page - attempt to add page to passthrough bio
|
|
|
|
* @q: the target queue
|
|
|
|
* @bio: destination bio
|
|
|
|
* @page: page to add
|
|
|
|
* @len: vec entry length
|
|
|
|
* @offset: vec entry offset
|
|
|
|
*
|
|
|
|
* Attempt to add a page to the bio_vec maplist. This can fail for a
|
|
|
|
* number of reasons, such as the bio being full or target block device
|
|
|
|
* limitations. The target block device must allow bio's up to PAGE_SIZE,
|
|
|
|
* so it is always possible to add a single page to an empty bio.
|
|
|
|
*
|
|
|
|
* This should only be used by passthrough bios.
|
|
|
|
*/
|
2019-03-17 04:01:08 -06:00
|
|
|
int bio_add_pc_page(struct request_queue *q, struct bio *bio,
|
|
|
|
struct page *page, unsigned int len, unsigned int offset)
|
|
|
|
{
|
2019-08-12 09:39:58 -06:00
|
|
|
bool same_page = false;
|
2020-05-12 02:55:46 -06:00
|
|
|
return bio_add_hw_page(q, bio, page, len, offset,
|
|
|
|
queue_max_hw_sectors(q), &same_page);
|
2019-03-17 04:01:08 -06:00
|
|
|
}
|
2009-09-26 08:19:21 -06:00
|
|
|
EXPORT_SYMBOL(bio_add_pc_page);
|
2005-11-11 04:30:27 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2018-06-01 10:03:05 -06:00
|
|
|
* __bio_try_merge_page - try appending data to an existing bvec.
|
|
|
|
* @bio: destination bio
|
2019-04-22 20:51:04 -06:00
|
|
|
* @page: start page to add
|
2018-06-01 10:03:05 -06:00
|
|
|
* @len: length of the data to add
|
2019-04-22 20:51:04 -06:00
|
|
|
* @off: offset of the data relative to @page
|
2019-06-17 03:14:11 -06:00
|
|
|
* @same_page: return if the segment has been merged inside the same page
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2018-06-01 10:03:05 -06:00
|
|
|
* Try to add the data at @page + @off to the last bvec of @bio. This is a
|
2020-07-30 19:42:28 -06:00
|
|
|
* useful optimisation for file systems with a block size smaller than the
|
2018-06-01 10:03:05 -06:00
|
|
|
* page size.
|
|
|
|
*
|
2019-04-22 20:51:04 -06:00
|
|
|
* Warn if (@len, @off) crosses pages in case that @same_page is true.
|
|
|
|
*
|
2018-06-01 10:03:05 -06:00
|
|
|
* Return %true on success or %false on failure.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2018-06-01 10:03:05 -06:00
|
|
|
bool __bio_try_merge_page(struct bio *bio, struct page *page,
|
2019-06-17 03:14:11 -06:00
|
|
|
unsigned int len, unsigned int off, bool *same_page)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-11-23 23:30:22 -07:00
|
|
|
if (WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED)))
|
2018-06-01 10:03:05 -06:00
|
|
|
return false;
|
2014-06-05 13:38:39 -06:00
|
|
|
|
2019-12-09 12:11:14 -07:00
|
|
|
if (bio->bi_vcnt > 0) {
|
2018-06-01 10:03:05 -06:00
|
|
|
struct bio_vec *bv = &bio->bi_io_vec[bio->bi_vcnt - 1];
|
2019-03-17 04:01:07 -06:00
|
|
|
|
|
|
|
if (page_is_mergeable(bv, page, len, off, same_page)) {
|
2020-09-08 21:14:25 -06:00
|
|
|
if (bio->bi_iter.bi_size > UINT_MAX - len) {
|
|
|
|
*same_page = false;
|
2019-12-09 12:11:14 -07:00
|
|
|
return false;
|
2020-09-08 21:14:25 -06:00
|
|
|
}
|
2019-03-17 04:01:07 -06:00
|
|
|
bv->bv_len += len;
|
|
|
|
bio->bi_iter.bi_size += len;
|
|
|
|
return true;
|
|
|
|
}
|
2013-11-23 23:30:22 -07:00
|
|
|
}
|
2018-06-01 10:03:05 -06:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__bio_try_merge_page);
|
2013-11-23 23:30:22 -07:00
|
|
|
|
2018-06-01 10:03:05 -06:00
|
|
|
/**
|
2019-04-22 20:51:04 -06:00
|
|
|
* __bio_add_page - add page(s) to a bio in a new segment
|
2018-06-01 10:03:05 -06:00
|
|
|
* @bio: destination bio
|
2019-04-22 20:51:04 -06:00
|
|
|
* @page: start page to add
|
|
|
|
* @len: length of the data to add, may cross pages
|
|
|
|
* @off: offset of the data relative to @page, may cross pages
|
2018-06-01 10:03:05 -06:00
|
|
|
*
|
|
|
|
* Add the data at @page + @off to @bio as a new bvec. The caller must ensure
|
|
|
|
* that @bio has space for another bvec.
|
|
|
|
*/
|
|
|
|
void __bio_add_page(struct bio *bio, struct page *page,
|
|
|
|
unsigned int len, unsigned int off)
|
|
|
|
{
|
|
|
|
struct bio_vec *bv = &bio->bi_io_vec[bio->bi_vcnt];
|
2013-11-23 23:30:22 -07:00
|
|
|
|
2018-06-01 10:03:05 -06:00
|
|
|
WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
|
2019-07-01 01:14:46 -06:00
|
|
|
WARN_ON_ONCE(bio_full(bio, len));
|
2018-06-01 10:03:05 -06:00
|
|
|
|
|
|
|
bv->bv_page = page;
|
|
|
|
bv->bv_offset = off;
|
|
|
|
bv->bv_len = len;
|
2013-11-23 23:30:22 -07:00
|
|
|
|
|
|
|
bio->bi_iter.bi_size += len;
|
2018-06-01 10:03:05 -06:00
|
|
|
bio->bi_vcnt++;
|
2019-08-08 13:03:00 -06:00
|
|
|
|
|
|
|
if (!bio_flagged(bio, BIO_WORKINGSET) && unlikely(PageWorkingset(page)))
|
|
|
|
bio_set_flag(bio, BIO_WORKINGSET);
|
2018-06-01 10:03:05 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__bio_add_page);
|
|
|
|
|
|
|
|
/**
|
2019-04-22 20:51:04 -06:00
|
|
|
* bio_add_page - attempt to add page(s) to bio
|
2018-06-01 10:03:05 -06:00
|
|
|
* @bio: destination bio
|
2019-04-22 20:51:04 -06:00
|
|
|
* @page: start page to add
|
|
|
|
* @len: vec entry length, may cross pages
|
|
|
|
* @offset: vec entry offset relative to @page, may cross pages
|
2018-06-01 10:03:05 -06:00
|
|
|
*
|
2019-04-22 20:51:04 -06:00
|
|
|
* Attempt to add page(s) to the bio_vec maplist. This will only fail
|
2018-06-01 10:03:05 -06:00
|
|
|
* if either bio->bi_vcnt == bio->bi_max_vecs or it's a cloned bio.
|
|
|
|
*/
|
|
|
|
int bio_add_page(struct bio *bio, struct page *page,
|
|
|
|
unsigned int len, unsigned int offset)
|
|
|
|
{
|
2019-06-17 03:14:11 -06:00
|
|
|
bool same_page = false;
|
|
|
|
|
|
|
|
if (!__bio_try_merge_page(bio, page, len, offset, &same_page)) {
|
2019-07-01 01:14:46 -06:00
|
|
|
if (bio_full(bio, len))
|
2018-06-01 10:03:05 -06:00
|
|
|
return 0;
|
|
|
|
__bio_add_page(bio, page, len, offset);
|
|
|
|
}
|
2013-11-23 23:30:22 -07:00
|
|
|
return len;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-09-26 08:19:21 -06:00
|
|
|
EXPORT_SYMBOL(bio_add_page);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-06-26 07:49:21 -06:00
|
|
|
void bio_release_pages(struct bio *bio, bool mark_dirty)
|
2019-04-11 00:23:30 -06:00
|
|
|
{
|
|
|
|
struct bvec_iter_all iter_all;
|
|
|
|
struct bio_vec *bvec;
|
|
|
|
|
2019-06-26 07:49:20 -06:00
|
|
|
if (bio_flagged(bio, BIO_NO_PAGE_REF))
|
|
|
|
return;
|
|
|
|
|
2019-06-26 07:49:21 -06:00
|
|
|
bio_for_each_segment_all(bvec, bio, iter_all) {
|
|
|
|
if (mark_dirty && !PageCompound(bvec->bv_page))
|
|
|
|
set_page_dirty_lock(bvec->bv_page);
|
2019-04-11 00:23:30 -06:00
|
|
|
put_page(bvec->bv_page);
|
2019-06-26 07:49:21 -06:00
|
|
|
}
|
2019-04-11 00:23:30 -06:00
|
|
|
}
|
2020-05-12 02:55:53 -06:00
|
|
|
EXPORT_SYMBOL_GPL(bio_release_pages);
|
2019-04-11 00:23:30 -06:00
|
|
|
|
2018-11-30 08:47:03 -07:00
|
|
|
static int __bio_iov_bvec_add_pages(struct bio *bio, struct iov_iter *iter)
|
|
|
|
{
|
|
|
|
const struct bio_vec *bv = iter->bvec;
|
|
|
|
unsigned int len;
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(iter->iov_offset > bv->bv_len))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
len = min_t(size_t, bv->bv_len - iter->iov_offset, iter->count);
|
|
|
|
size = bio_add_page(bio, bv->bv_page, len,
|
|
|
|
bv->bv_offset + iter->iov_offset);
|
2019-04-11 00:23:28 -06:00
|
|
|
if (unlikely(size != len))
|
|
|
|
return -EINVAL;
|
|
|
|
iov_iter_advance(iter, size);
|
|
|
|
return 0;
|
2018-11-30 08:47:03 -07:00
|
|
|
}
|
|
|
|
|
2018-09-20 00:28:21 -06:00
|
|
|
#define PAGE_PTRS_PER_BVEC (sizeof(struct bio_vec) / sizeof(struct page *))
|
|
|
|
|
2016-10-31 11:59:24 -06:00
|
|
|
/**
|
2018-07-25 15:15:09 -06:00
|
|
|
* __bio_iov_iter_get_pages - pin user or kernel pages and add them to a bio
|
2016-10-31 11:59:24 -06:00
|
|
|
* @bio: bio to add pages to
|
|
|
|
* @iter: iov iterator describing the region to be mapped
|
|
|
|
*
|
2018-07-25 15:15:09 -06:00
|
|
|
* Pins pages from *iter and appends them to @bio's bvec array. The
|
2016-10-31 11:59:24 -06:00
|
|
|
* pages will have to be released using put_page() when done.
|
2018-07-25 15:15:09 -06:00
|
|
|
* For multi-segment *iter, this function only adds pages from the
|
2020-07-30 19:42:28 -06:00
|
|
|
* next non-empty segment of the iov iterator.
|
2016-10-31 11:59:24 -06:00
|
|
|
*/
|
2018-07-25 15:15:09 -06:00
|
|
|
static int __bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter)
|
2016-10-31 11:59:24 -06:00
|
|
|
{
|
2018-09-20 00:28:21 -06:00
|
|
|
unsigned short nr_pages = bio->bi_max_vecs - bio->bi_vcnt;
|
|
|
|
unsigned short entries_left = bio->bi_max_vecs - bio->bi_vcnt;
|
2016-10-31 11:59:24 -06:00
|
|
|
struct bio_vec *bv = bio->bi_io_vec + bio->bi_vcnt;
|
|
|
|
struct page **pages = (struct page **)bv;
|
2019-06-17 03:14:12 -06:00
|
|
|
bool same_page = false;
|
2018-09-20 00:28:21 -06:00
|
|
|
ssize_t size, left;
|
|
|
|
unsigned len, i;
|
2018-07-25 15:15:07 -06:00
|
|
|
size_t offset;
|
2018-09-20 00:28:21 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Move page array up in the allocated memory for the bio vecs as far as
|
|
|
|
* possible so that we can start filling biovecs from the beginning
|
|
|
|
* without overwriting the temporary page array.
|
|
|
|
*/
|
|
|
|
BUILD_BUG_ON(PAGE_PTRS_PER_BVEC < 2);
|
|
|
|
pages += entries_left * (PAGE_PTRS_PER_BVEC - 1);
|
2016-10-31 11:59:24 -06:00
|
|
|
|
|
|
|
size = iov_iter_get_pages(iter, pages, LONG_MAX, nr_pages, &offset);
|
|
|
|
if (unlikely(size <= 0))
|
|
|
|
return size ? size : -EFAULT;
|
|
|
|
|
2018-09-20 00:28:21 -06:00
|
|
|
for (left = size, i = 0; left > 0; left -= len, i++) {
|
|
|
|
struct page *page = pages[i];
|
2016-10-31 11:59:24 -06:00
|
|
|
|
2018-09-20 00:28:21 -06:00
|
|
|
len = min_t(size_t, PAGE_SIZE - offset, left);
|
2019-06-17 03:14:12 -06:00
|
|
|
|
|
|
|
if (__bio_try_merge_page(bio, page, len, offset, &same_page)) {
|
|
|
|
if (same_page)
|
|
|
|
put_page(page);
|
|
|
|
} else {
|
2019-07-01 01:14:46 -06:00
|
|
|
if (WARN_ON_ONCE(bio_full(bio, len)))
|
2019-06-17 03:14:12 -06:00
|
|
|
return -EINVAL;
|
|
|
|
__bio_add_page(bio, page, len, offset);
|
|
|
|
}
|
2018-09-20 00:28:21 -06:00
|
|
|
offset = 0;
|
2016-10-31 11:59:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
iov_iter_advance(iter, size);
|
|
|
|
return 0;
|
|
|
|
}
|
2018-07-25 15:15:09 -06:00
|
|
|
|
2020-05-12 02:55:47 -06:00
|
|
|
static int __bio_iov_append_get_pages(struct bio *bio, struct iov_iter *iter)
|
|
|
|
{
|
|
|
|
unsigned short nr_pages = bio->bi_max_vecs - bio->bi_vcnt;
|
|
|
|
unsigned short entries_left = bio->bi_max_vecs - bio->bi_vcnt;
|
|
|
|
struct request_queue *q = bio->bi_disk->queue;
|
|
|
|
unsigned int max_append_sectors = queue_max_zone_append_sectors(q);
|
|
|
|
struct bio_vec *bv = bio->bi_io_vec + bio->bi_vcnt;
|
|
|
|
struct page **pages = (struct page **)bv;
|
|
|
|
ssize_t size, left;
|
|
|
|
unsigned len, i;
|
|
|
|
size_t offset;
|
2020-10-28 01:25:36 -06:00
|
|
|
int ret = 0;
|
2020-05-12 02:55:47 -06:00
|
|
|
|
|
|
|
if (WARN_ON_ONCE(!max_append_sectors))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move page array up in the allocated memory for the bio vecs as far as
|
|
|
|
* possible so that we can start filling biovecs from the beginning
|
|
|
|
* without overwriting the temporary page array.
|
|
|
|
*/
|
|
|
|
BUILD_BUG_ON(PAGE_PTRS_PER_BVEC < 2);
|
|
|
|
pages += entries_left * (PAGE_PTRS_PER_BVEC - 1);
|
|
|
|
|
|
|
|
size = iov_iter_get_pages(iter, pages, LONG_MAX, nr_pages, &offset);
|
|
|
|
if (unlikely(size <= 0))
|
|
|
|
return size ? size : -EFAULT;
|
|
|
|
|
|
|
|
for (left = size, i = 0; left > 0; left -= len, i++) {
|
|
|
|
struct page *page = pages[i];
|
|
|
|
bool same_page = false;
|
|
|
|
|
|
|
|
len = min_t(size_t, PAGE_SIZE - offset, left);
|
|
|
|
if (bio_add_hw_page(q, bio, page, len, offset,
|
2020-10-28 01:25:36 -06:00
|
|
|
max_append_sectors, &same_page) != len) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-05-12 02:55:47 -06:00
|
|
|
if (same_page)
|
|
|
|
put_page(page);
|
|
|
|
offset = 0;
|
|
|
|
}
|
|
|
|
|
2020-10-28 01:25:36 -06:00
|
|
|
iov_iter_advance(iter, size - left);
|
|
|
|
return ret;
|
2020-05-12 02:55:47 -06:00
|
|
|
}
|
|
|
|
|
2018-07-25 15:15:09 -06:00
|
|
|
/**
|
2018-11-30 08:47:03 -07:00
|
|
|
* bio_iov_iter_get_pages - add user or kernel pages to a bio
|
2018-07-25 15:15:09 -06:00
|
|
|
* @bio: bio to add pages to
|
2018-11-30 08:47:03 -07:00
|
|
|
* @iter: iov iterator describing the region to be added
|
|
|
|
*
|
|
|
|
* This takes either an iterator pointing to user memory, or one pointing to
|
|
|
|
* kernel pages (BVEC iterator). If we're adding user pages, we pin them and
|
|
|
|
* map them into the kernel. On IO completion, the caller should put those
|
2019-02-27 13:13:23 -07:00
|
|
|
* pages. If we're adding kernel pages, and the caller told us it's safe to
|
|
|
|
* do so, we just have to add the pages to the bio directly. We don't grab an
|
|
|
|
* extra reference to those pages (the user should already have that), and we
|
|
|
|
* don't put the page on IO completion. The caller needs to check if the bio is
|
|
|
|
* flagged BIO_NO_PAGE_REF on IO completion. If it isn't, then pages should be
|
|
|
|
* released.
|
2018-07-25 15:15:09 -06:00
|
|
|
*
|
|
|
|
* The function tries, but does not guarantee, to pin as many pages as
|
2020-09-09 03:44:33 -06:00
|
|
|
* fit into the bio, or are requested in @iter, whatever is smaller. If
|
2018-11-30 08:47:03 -07:00
|
|
|
* MM encounters an error pinning the requested pages, it stops. Error
|
|
|
|
* is returned only if 0 pages could be pinned.
|
2018-07-25 15:15:09 -06:00
|
|
|
*/
|
|
|
|
int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter)
|
|
|
|
{
|
2018-11-30 08:47:03 -07:00
|
|
|
const bool is_bvec = iov_iter_is_bvec(iter);
|
2019-04-11 00:23:29 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (WARN_ON_ONCE(bio->bi_vcnt))
|
|
|
|
return -EINVAL;
|
2018-07-25 15:15:09 -06:00
|
|
|
|
|
|
|
do {
|
2020-05-12 02:55:47 -06:00
|
|
|
if (bio_op(bio) == REQ_OP_ZONE_APPEND) {
|
|
|
|
if (WARN_ON_ONCE(is_bvec))
|
|
|
|
return -EINVAL;
|
|
|
|
ret = __bio_iov_append_get_pages(bio, iter);
|
|
|
|
} else {
|
|
|
|
if (is_bvec)
|
|
|
|
ret = __bio_iov_bvec_add_pages(bio, iter);
|
|
|
|
else
|
|
|
|
ret = __bio_iov_iter_get_pages(bio, iter);
|
|
|
|
}
|
2019-07-01 01:14:46 -06:00
|
|
|
} while (!ret && iov_iter_count(iter) && !bio_full(bio, 0));
|
2018-07-25 15:15:09 -06:00
|
|
|
|
2019-06-26 07:49:28 -06:00
|
|
|
if (is_bvec)
|
2019-04-11 00:23:30 -06:00
|
|
|
bio_set_flag(bio, BIO_NO_PAGE_REF);
|
2019-04-11 00:23:29 -06:00
|
|
|
return bio->bi_vcnt ? 0 : ret;
|
2018-07-25 15:15:09 -06:00
|
|
|
}
|
2020-05-12 02:55:53 -06:00
|
|
|
EXPORT_SYMBOL_GPL(bio_iov_iter_get_pages);
|
2016-10-31 11:59:24 -06:00
|
|
|
|
2015-07-20 07:29:37 -06:00
|
|
|
static void submit_bio_wait_endio(struct bio *bio)
|
2012-09-10 15:41:12 -06:00
|
|
|
{
|
2017-10-25 02:55:57 -06:00
|
|
|
complete(bio->bi_private);
|
2012-09-10 15:41:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* submit_bio_wait - submit a bio, and wait until it completes
|
|
|
|
* @bio: The &struct bio which describes the I/O
|
|
|
|
*
|
|
|
|
* Simple wrapper around submit_bio(). Returns 0 on success, or the error from
|
|
|
|
* bio_endio() on failure.
|
2017-08-02 02:25:21 -06:00
|
|
|
*
|
|
|
|
* WARNING: Unlike to how submit_bio() is usually used, this function does not
|
|
|
|
* result in bio reference to be consumed. The caller must drop the reference
|
|
|
|
* on his own.
|
2012-09-10 15:41:12 -06:00
|
|
|
*/
|
2016-06-05 13:31:41 -06:00
|
|
|
int submit_bio_wait(struct bio *bio)
|
2012-09-10 15:41:12 -06:00
|
|
|
{
|
2017-10-25 02:56:05 -06:00
|
|
|
DECLARE_COMPLETION_ONSTACK_MAP(done, bio->bi_disk->lockdep_map);
|
2020-03-17 21:43:36 -06:00
|
|
|
unsigned long hang_check;
|
2012-09-10 15:41:12 -06:00
|
|
|
|
2017-10-25 02:55:57 -06:00
|
|
|
bio->bi_private = &done;
|
2012-09-10 15:41:12 -06:00
|
|
|
bio->bi_end_io = submit_bio_wait_endio;
|
2016-08-05 15:35:16 -06:00
|
|
|
bio->bi_opf |= REQ_SYNC;
|
2016-06-05 13:31:41 -06:00
|
|
|
submit_bio(bio);
|
2020-03-17 21:43:36 -06:00
|
|
|
|
|
|
|
/* Prevent hang_check timer from firing at us during very long I/O */
|
|
|
|
hang_check = sysctl_hung_task_timeout_secs;
|
|
|
|
if (hang_check)
|
|
|
|
while (!wait_for_completion_io_timeout(&done,
|
|
|
|
hang_check * (HZ/2)))
|
|
|
|
;
|
|
|
|
else
|
|
|
|
wait_for_completion_io(&done);
|
2012-09-10 15:41:12 -06:00
|
|
|
|
2017-10-25 02:55:57 -06:00
|
|
|
return blk_status_to_errno(bio->bi_status);
|
2012-09-10 15:41:12 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(submit_bio_wait);
|
|
|
|
|
2012-09-28 14:17:55 -06:00
|
|
|
/**
|
|
|
|
* bio_advance - increment/complete a bio by some number of bytes
|
|
|
|
* @bio: bio to advance
|
|
|
|
* @bytes: number of bytes to complete
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
void bio_advance(struct bio *bio, unsigned bytes)
|
|
|
|
{
|
|
|
|
if (bio_integrity(bio))
|
|
|
|
bio_integrity_advance(bio, bytes);
|
|
|
|
|
block: Inline encryption support for blk-mq
We must have some way of letting a storage device driver know what
encryption context it should use for en/decrypting a request. However,
it's the upper layers (like the filesystem/fscrypt) that know about and
manages encryption contexts. As such, when the upper layer submits a bio
to the block layer, and this bio eventually reaches a device driver with
support for inline encryption, the device driver will need to have been
told the encryption context for that bio.
We want to communicate the encryption context from the upper layer to the
storage device along with the bio, when the bio is submitted to the block
layer. To do this, we add a struct bio_crypt_ctx to struct bio, which can
represent an encryption context (note that we can't use the bi_private
field in struct bio to do this because that field does not function to pass
information across layers in the storage stack). We also introduce various
functions to manipulate the bio_crypt_ctx and make the bio/request merging
logic aware of the bio_crypt_ctx.
We also make changes to blk-mq to make it handle bios with encryption
contexts. blk-mq can merge many bios into the same request. These bios need
to have contiguous data unit numbers (the necessary changes to blk-merge
are also made to ensure this) - as such, it suffices to keep the data unit
number of just the first bio, since that's all a storage driver needs to
infer the data unit number to use for each data block in each bio in a
request. blk-mq keeps track of the encryption context to be used for all
the bios in a request with the request's rq_crypt_ctx. When the first bio
is added to an empty request, blk-mq will program the encryption context
of that bio into the request_queue's keyslot manager, and store the
returned keyslot in the request's rq_crypt_ctx. All the functions to
operate on encryption contexts are in blk-crypto.c.
Upper layers only need to call bio_crypt_set_ctx with the encryption key,
algorithm and data_unit_num; they don't have to worry about getting a
keyslot for each encryption context, as blk-mq/blk-crypto handles that.
Blk-crypto also makes it possible for request-based layered devices like
dm-rq to make use of inline encryption hardware by cloning the
rq_crypt_ctx and programming a keyslot in the new request_queue when
necessary.
Note that any user of the block layer can submit bios with an
encryption context, such as filesystems, device-mapper targets, etc.
Signed-off-by: Satya Tangirala <satyat@google.com>
Reviewed-by: Eric Biggers <ebiggers@google.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2020-05-13 18:37:18 -06:00
|
|
|
bio_crypt_advance(bio, bytes);
|
2013-08-07 15:26:21 -06:00
|
|
|
bio_advance_iter(bio, &bio->bi_iter, bytes);
|
2012-09-28 14:17:55 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bio_advance);
|
|
|
|
|
2018-05-08 19:33:54 -06:00
|
|
|
void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,
|
|
|
|
struct bio *src, struct bvec_iter *src_iter)
|
2012-09-10 14:57:51 -06:00
|
|
|
{
|
2013-08-07 15:26:39 -06:00
|
|
|
struct bio_vec src_bv, dst_bv;
|
2012-09-10 14:57:51 -06:00
|
|
|
void *src_p, *dst_p;
|
2013-08-07 15:26:39 -06:00
|
|
|
unsigned bytes;
|
2012-09-10 14:57:51 -06:00
|
|
|
|
2018-05-08 19:33:54 -06:00
|
|
|
while (src_iter->bi_size && dst_iter->bi_size) {
|
|
|
|
src_bv = bio_iter_iovec(src, *src_iter);
|
|
|
|
dst_bv = bio_iter_iovec(dst, *dst_iter);
|
2013-08-07 15:26:39 -06:00
|
|
|
|
|
|
|
bytes = min(src_bv.bv_len, dst_bv.bv_len);
|
2012-09-10 14:57:51 -06:00
|
|
|
|
2013-08-07 15:26:39 -06:00
|
|
|
src_p = kmap_atomic(src_bv.bv_page);
|
|
|
|
dst_p = kmap_atomic(dst_bv.bv_page);
|
2012-09-10 14:57:51 -06:00
|
|
|
|
2013-08-07 15:26:39 -06:00
|
|
|
memcpy(dst_p + dst_bv.bv_offset,
|
|
|
|
src_p + src_bv.bv_offset,
|
2012-09-10 14:57:51 -06:00
|
|
|
bytes);
|
|
|
|
|
|
|
|
kunmap_atomic(dst_p);
|
|
|
|
kunmap_atomic(src_p);
|
|
|
|
|
2018-05-08 19:33:55 -06:00
|
|
|
flush_dcache_page(dst_bv.bv_page);
|
|
|
|
|
2018-05-08 19:33:54 -06:00
|
|
|
bio_advance_iter(src, src_iter, bytes);
|
|
|
|
bio_advance_iter(dst, dst_iter, bytes);
|
2012-09-10 14:57:51 -06:00
|
|
|
}
|
|
|
|
}
|
2018-05-08 19:33:53 -06:00
|
|
|
EXPORT_SYMBOL(bio_copy_data_iter);
|
|
|
|
|
|
|
|
/**
|
2018-05-08 19:33:54 -06:00
|
|
|
* bio_copy_data - copy contents of data buffers from one bio to another
|
|
|
|
* @src: source bio
|
|
|
|
* @dst: destination bio
|
2018-05-08 19:33:53 -06:00
|
|
|
*
|
|
|
|
* Stops when it reaches the end of either @src or @dst - that is, copies
|
|
|
|
* min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of bios).
|
|
|
|
*/
|
|
|
|
void bio_copy_data(struct bio *dst, struct bio *src)
|
|
|
|
{
|
2018-05-08 19:33:54 -06:00
|
|
|
struct bvec_iter src_iter = src->bi_iter;
|
|
|
|
struct bvec_iter dst_iter = dst->bi_iter;
|
|
|
|
|
|
|
|
bio_copy_data_iter(dst, &dst_iter, src, &src_iter);
|
2018-05-08 19:33:53 -06:00
|
|
|
}
|
2012-09-10 14:57:51 -06:00
|
|
|
EXPORT_SYMBOL(bio_copy_data);
|
|
|
|
|
2018-05-08 19:33:54 -06:00
|
|
|
/**
|
|
|
|
* bio_list_copy_data - copy contents of data buffers from one chain of bios to
|
|
|
|
* another
|
|
|
|
* @src: source bio list
|
|
|
|
* @dst: destination bio list
|
|
|
|
*
|
|
|
|
* Stops when it reaches the end of either the @src list or @dst list - that is,
|
|
|
|
* copies min(src->bi_size, dst->bi_size) bytes (or the equivalent for lists of
|
|
|
|
* bios).
|
|
|
|
*/
|
|
|
|
void bio_list_copy_data(struct bio *dst, struct bio *src)
|
|
|
|
{
|
|
|
|
struct bvec_iter src_iter = src->bi_iter;
|
|
|
|
struct bvec_iter dst_iter = dst->bi_iter;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
if (!src_iter.bi_size) {
|
|
|
|
src = src->bi_next;
|
|
|
|
if (!src)
|
|
|
|
break;
|
|
|
|
|
|
|
|
src_iter = src->bi_iter;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!dst_iter.bi_size) {
|
|
|
|
dst = dst->bi_next;
|
|
|
|
if (!dst)
|
|
|
|
break;
|
|
|
|
|
|
|
|
dst_iter = dst->bi_iter;
|
|
|
|
}
|
|
|
|
|
|
|
|
bio_copy_data_iter(dst, &dst_iter, src, &src_iter);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bio_list_copy_data);
|
|
|
|
|
2016-09-22 01:10:01 -06:00
|
|
|
void bio_free_pages(struct bio *bio)
|
2015-01-18 08:16:30 -07:00
|
|
|
{
|
|
|
|
struct bio_vec *bvec;
|
2019-02-15 04:13:19 -07:00
|
|
|
struct bvec_iter_all iter_all;
|
2015-01-18 08:16:30 -07:00
|
|
|
|
2019-04-25 01:03:00 -06:00
|
|
|
bio_for_each_segment_all(bvec, bio, iter_all)
|
2015-01-18 08:16:30 -07:00
|
|
|
__free_page(bvec->bv_page);
|
|
|
|
}
|
2016-09-22 01:10:01 -06:00
|
|
|
EXPORT_SYMBOL(bio_free_pages);
|
2015-01-18 08:16:30 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* bio_set_pages_dirty() and bio_check_pages_dirty() are support functions
|
|
|
|
* for performing direct-IO in BIOs.
|
|
|
|
*
|
|
|
|
* The problem is that we cannot run set_page_dirty() from interrupt context
|
|
|
|
* because the required locks are not interrupt-safe. So what we can do is to
|
|
|
|
* mark the pages dirty _before_ performing IO. And in interrupt context,
|
|
|
|
* check that the pages are still dirty. If so, fine. If not, redirty them
|
|
|
|
* in process context.
|
|
|
|
*
|
|
|
|
* We special-case compound pages here: normally this means reads into hugetlb
|
|
|
|
* pages. The logic in here doesn't really work right for compound pages
|
|
|
|
* because the VM does not uniformly chase down the head page in all cases.
|
|
|
|
* But dirtiness of compound pages is pretty meaningless anyway: the VM doesn't
|
|
|
|
* handle them at all. So we skip compound pages here at an early stage.
|
|
|
|
*
|
|
|
|
* Note that this code is very hard to test under normal circumstances because
|
|
|
|
* direct-io pins the pages with get_user_pages(). This makes
|
|
|
|
* is_page_cache_freeable return false, and the VM will not clean the pages.
|
2012-07-25 09:12:08 -06:00
|
|
|
* But other code (eg, flusher threads) could clean the pages if they are mapped
|
2005-04-16 16:20:36 -06:00
|
|
|
* pagecache.
|
|
|
|
*
|
|
|
|
* Simply disabling the call to bio_set_pages_dirty() is a good way to test the
|
|
|
|
* deferred bio dirtying paths.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bio_set_pages_dirty() will mark all the bio's pages as dirty.
|
|
|
|
*/
|
|
|
|
void bio_set_pages_dirty(struct bio *bio)
|
|
|
|
{
|
2012-09-05 16:22:02 -06:00
|
|
|
struct bio_vec *bvec;
|
2019-02-15 04:13:19 -07:00
|
|
|
struct bvec_iter_all iter_all;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-04-25 01:03:00 -06:00
|
|
|
bio_for_each_segment_all(bvec, bio, iter_all) {
|
2018-07-24 06:04:13 -06:00
|
|
|
if (!PageCompound(bvec->bv_page))
|
|
|
|
set_page_dirty_lock(bvec->bv_page);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bio_check_pages_dirty() will check that all the BIO's pages are still dirty.
|
|
|
|
* If they are, then fine. If, however, some pages are clean then they must
|
|
|
|
* have been written out during the direct-IO read. So we take another ref on
|
2018-07-24 06:04:12 -06:00
|
|
|
* the BIO and re-dirty the pages in process context.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* It is expected that bio_check_pages_dirty() will wholly own the BIO from
|
2016-04-01 06:29:48 -06:00
|
|
|
* here on. It will run one put_page() against each page and will run one
|
|
|
|
* bio_put() against the BIO.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2006-11-22 07:55:48 -07:00
|
|
|
static void bio_dirty_fn(struct work_struct *work);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-22 07:55:48 -07:00
|
|
|
static DECLARE_WORK(bio_dirty_work, bio_dirty_fn);
|
2005-04-16 16:20:36 -06:00
|
|
|
static DEFINE_SPINLOCK(bio_dirty_lock);
|
|
|
|
static struct bio *bio_dirty_list;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This runs in process context
|
|
|
|
*/
|
2006-11-22 07:55:48 -07:00
|
|
|
static void bio_dirty_fn(struct work_struct *work)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2018-07-24 06:04:12 -06:00
|
|
|
struct bio *bio, *next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-07-24 06:04:12 -06:00
|
|
|
spin_lock_irq(&bio_dirty_lock);
|
|
|
|
next = bio_dirty_list;
|
2005-04-16 16:20:36 -06:00
|
|
|
bio_dirty_list = NULL;
|
2018-07-24 06:04:12 -06:00
|
|
|
spin_unlock_irq(&bio_dirty_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-07-24 06:04:12 -06:00
|
|
|
while ((bio = next) != NULL) {
|
|
|
|
next = bio->bi_private;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-06-26 07:49:21 -06:00
|
|
|
bio_release_pages(bio, true);
|
2005-04-16 16:20:36 -06:00
|
|
|
bio_put(bio);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void bio_check_pages_dirty(struct bio *bio)
|
|
|
|
{
|
2012-09-05 16:22:02 -06:00
|
|
|
struct bio_vec *bvec;
|
2018-07-24 06:04:12 -06:00
|
|
|
unsigned long flags;
|
2019-02-15 04:13:19 -07:00
|
|
|
struct bvec_iter_all iter_all;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-04-25 01:03:00 -06:00
|
|
|
bio_for_each_segment_all(bvec, bio, iter_all) {
|
2018-07-24 06:04:12 -06:00
|
|
|
if (!PageDirty(bvec->bv_page) && !PageCompound(bvec->bv_page))
|
|
|
|
goto defer;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2019-06-26 07:49:21 -06:00
|
|
|
bio_release_pages(bio, false);
|
2018-07-24 06:04:12 -06:00
|
|
|
bio_put(bio);
|
|
|
|
return;
|
|
|
|
defer:
|
|
|
|
spin_lock_irqsave(&bio_dirty_lock, flags);
|
|
|
|
bio->bi_private = bio_dirty_list;
|
|
|
|
bio_dirty_list = bio;
|
|
|
|
spin_unlock_irqrestore(&bio_dirty_lock, flags);
|
|
|
|
schedule_work(&bio_dirty_work);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2015-04-17 16:15:18 -06:00
|
|
|
static inline bool bio_remaining_done(struct bio *bio)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If we're not chaining, then ->__bi_remaining is always 1 and
|
|
|
|
* we always end io on the first invocation.
|
|
|
|
*/
|
|
|
|
if (!bio_flagged(bio, BIO_CHAIN))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
BUG_ON(atomic_read(&bio->__bi_remaining) <= 0);
|
|
|
|
|
2015-05-22 07:14:03 -06:00
|
|
|
if (atomic_dec_and_test(&bio->__bi_remaining)) {
|
2015-07-24 12:37:59 -06:00
|
|
|
bio_clear_flag(bio, BIO_CHAIN);
|
2015-04-17 16:15:18 -06:00
|
|
|
return true;
|
2015-05-22 07:14:03 -06:00
|
|
|
}
|
2015-04-17 16:15:18 -06:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* bio_endio - end I/O on a bio
|
|
|
|
* @bio: bio
|
|
|
|
*
|
|
|
|
* Description:
|
2015-07-20 07:29:37 -06:00
|
|
|
* bio_endio() will end I/O on the whole bio. bio_endio() is the preferred
|
|
|
|
* way to end I/O on a bio. No one should call bi_end_io() directly on a
|
|
|
|
* bio unless they own it and thus know that it has an end_io function.
|
block: trace completion of all bios.
Currently only dm and md/raid5 bios trigger
trace_block_bio_complete(). Now that we have bio_chain() and
bio_inc_remaining(), it is not possible, in general, for a driver to
know when the bio is really complete. Only bio_endio() knows that.
So move the trace_block_bio_complete() call to bio_endio().
Now trace_block_bio_complete() pairs with trace_block_bio_queue().
Any bio for which a 'queue' event is traced, will subsequently
generate a 'complete' event.
There are a few cases where completion tracing is not wanted.
1/ If blk_update_request() has already generated a completion
trace event at the 'request' level, there is no point generating
one at the bio level too. In this case the bi_sector and bi_size
will have changed, so the bio level event would be wrong
2/ If the bio hasn't actually been queued yet, but is being aborted
early, then a trace event could be confusing. Some filesystems
call bio_endio() but do not want tracing.
3/ The bio_integrity code interposes itself by replacing bi_end_io,
then restoring it and calling bio_endio() again. This would produce
two identical trace events if left like that.
To handle these, we introduce a flag BIO_TRACE_COMPLETION and only
produce the trace event when this is set.
We address point 1 above by clearing the flag in blk_update_request().
We address point 2 above by only setting the flag when
generic_make_request() is called.
We address point 3 above by clearing the flag after generating a
completion event.
When bio_split() is used on a bio, particularly in blk_queue_split(),
there is an extra complication. A new bio is split off the front, and
may be handle directly without going through generic_make_request().
The old bio, which has been advanced, is passed to
generic_make_request(), so it will trigger a trace event a second
time.
Probably the best result when a split happens is to see a single
'queue' event for the whole bio, then multiple 'complete' events - one
for each component. To achieve this was can:
- copy the BIO_TRACE_COMPLETION flag to the new bio in bio_split()
- avoid generating a 'queue' event if BIO_TRACE_COMPLETION is already set.
This way, the split-off bio won't create a queue event, the original
won't either even if it re-submitted to generic_make_request(),
but both will produce completion events, each for their own range.
So if generic_make_request() is called (which generates a QUEUED
event), then bi_endio() will create a single COMPLETE event for each
range that the bio is split into, unless the driver has explicitly
requested it not to.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2017-04-07 09:40:52 -06:00
|
|
|
*
|
|
|
|
* bio_endio() can be called several times on a bio that has been chained
|
|
|
|
* using bio_chain(). The ->bi_end_io() function will only be called the
|
|
|
|
* last time. At this point the BLK_TA_COMPLETE tracing event will be
|
|
|
|
* generated if BIO_TRACE_COMPLETION is set.
|
2005-04-16 16:20:36 -06:00
|
|
|
**/
|
2015-07-20 07:29:37 -06:00
|
|
|
void bio_endio(struct bio *bio)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2016-03-11 09:34:52 -07:00
|
|
|
again:
|
2016-03-11 09:34:53 -07:00
|
|
|
if (!bio_remaining_done(bio))
|
2016-03-11 09:34:52 -07:00
|
|
|
return;
|
2017-07-03 16:58:43 -06:00
|
|
|
if (!bio_integrity_endio(bio))
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-07-03 09:15:00 -06:00
|
|
|
if (bio->bi_disk)
|
|
|
|
rq_qos_done_bio(bio->bi_disk->queue, bio);
|
|
|
|
|
2016-03-11 09:34:52 -07:00
|
|
|
/*
|
|
|
|
* Need to have a real endio function for chained bios, otherwise
|
|
|
|
* various corner cases will break (like stacking block devices that
|
|
|
|
* save/restore bi_end_io) - however, we want to avoid unbounded
|
|
|
|
* recursion and blowing the stack. Tail call optimization would
|
|
|
|
* handle this, but compiling with frame pointers also disables
|
|
|
|
* gcc's sibling call optimization.
|
|
|
|
*/
|
|
|
|
if (bio->bi_end_io == bio_chain_endio) {
|
|
|
|
bio = __bio_chain_endio(bio);
|
|
|
|
goto again;
|
2013-11-23 19:34:15 -07:00
|
|
|
}
|
2016-03-11 09:34:52 -07:00
|
|
|
|
2017-08-23 11:10:32 -06:00
|
|
|
if (bio->bi_disk && bio_flagged(bio, BIO_TRACE_COMPLETION)) {
|
2020-06-02 23:14:43 -06:00
|
|
|
trace_block_bio_complete(bio->bi_disk->queue, bio);
|
block: trace completion of all bios.
Currently only dm and md/raid5 bios trigger
trace_block_bio_complete(). Now that we have bio_chain() and
bio_inc_remaining(), it is not possible, in general, for a driver to
know when the bio is really complete. Only bio_endio() knows that.
So move the trace_block_bio_complete() call to bio_endio().
Now trace_block_bio_complete() pairs with trace_block_bio_queue().
Any bio for which a 'queue' event is traced, will subsequently
generate a 'complete' event.
There are a few cases where completion tracing is not wanted.
1/ If blk_update_request() has already generated a completion
trace event at the 'request' level, there is no point generating
one at the bio level too. In this case the bi_sector and bi_size
will have changed, so the bio level event would be wrong
2/ If the bio hasn't actually been queued yet, but is being aborted
early, then a trace event could be confusing. Some filesystems
call bio_endio() but do not want tracing.
3/ The bio_integrity code interposes itself by replacing bi_end_io,
then restoring it and calling bio_endio() again. This would produce
two identical trace events if left like that.
To handle these, we introduce a flag BIO_TRACE_COMPLETION and only
produce the trace event when this is set.
We address point 1 above by clearing the flag in blk_update_request().
We address point 2 above by only setting the flag when
generic_make_request() is called.
We address point 3 above by clearing the flag after generating a
completion event.
When bio_split() is used on a bio, particularly in blk_queue_split(),
there is an extra complication. A new bio is split off the front, and
may be handle directly without going through generic_make_request().
The old bio, which has been advanced, is passed to
generic_make_request(), so it will trigger a trace event a second
time.
Probably the best result when a split happens is to see a single
'queue' event for the whole bio, then multiple 'complete' events - one
for each component. To achieve this was can:
- copy the BIO_TRACE_COMPLETION flag to the new bio in bio_split()
- avoid generating a 'queue' event if BIO_TRACE_COMPLETION is already set.
This way, the split-off bio won't create a queue event, the original
won't either even if it re-submitted to generic_make_request(),
but both will produce completion events, each for their own range.
So if generic_make_request() is called (which generates a QUEUED
event), then bi_endio() will create a single COMPLETE event for each
range that the bio is split into, unless the driver has explicitly
requested it not to.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2017-04-07 09:40:52 -06:00
|
|
|
bio_clear_flag(bio, BIO_TRACE_COMPLETION);
|
|
|
|
}
|
|
|
|
|
blk-throttle: add a simple idle detection
A cgroup gets assigned a low limit, but the cgroup could never dispatch
enough IO to cross the low limit. In such case, the queue state machine
will remain in LIMIT_LOW state and all other cgroups will be throttled
according to low limit. This is unfair for other cgroups. We should
treat the cgroup idle and upgrade the state machine to lower state.
We also have a downgrade logic. If the state machine upgrades because of
cgroup idle (real idle), the state machine will downgrade soon as the
cgroup is below its low limit. This isn't what we want. A more
complicated case is cgroup isn't idle when queue is in LIMIT_LOW. But
when queue gets upgraded to lower state, other cgroups could dispatch
more IO and this cgroup can't dispatch enough IO, so the cgroup is below
its low limit and looks like idle (fake idle). In this case, the queue
should downgrade soon. The key to determine if we should do downgrade is
to detect if cgroup is truely idle.
Unfortunately it's very hard to determine if a cgroup is real idle. This
patch uses the 'think time check' idea from CFQ for the purpose. Please
note, the idea doesn't work for all workloads. For example, a workload
with io depth 8 has disk utilization 100%, hence think time is 0, eg,
not idle. But the workload can run higher bandwidth with io depth 16.
Compared to io depth 16, the io depth 8 workload is idle. We use the
idea to roughly determine if a cgroup is idle.
We treat a cgroup idle if its think time is above a threshold (by
default 1ms for SSD and 100ms for HD). The idea is think time above the
threshold will start to harm performance. HD is much slower so a longer
think time is ok.
The patch (and the latter patches) uses 'unsigned long' to track time.
We convert 'ns' to 'us' with 'ns >> 10'. This is fast but loses
precision, should not a big deal.
Signed-off-by: Shaohua Li <shli@fb.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2017-03-27 11:51:41 -06:00
|
|
|
blk_throtl_bio_endio(bio);
|
2017-07-10 12:40:17 -06:00
|
|
|
/* release cgroup info */
|
|
|
|
bio_uninit(bio);
|
2016-03-11 09:34:52 -07:00
|
|
|
if (bio->bi_end_io)
|
|
|
|
bio->bi_end_io(bio);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-09-26 08:19:21 -06:00
|
|
|
EXPORT_SYMBOL(bio_endio);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-11-23 19:21:01 -07:00
|
|
|
/**
|
|
|
|
* bio_split - split a bio
|
|
|
|
* @bio: bio to split
|
|
|
|
* @sectors: number of sectors to split from the front of @bio
|
|
|
|
* @gfp: gfp mask
|
|
|
|
* @bs: bio set to allocate from
|
|
|
|
*
|
|
|
|
* Allocates and returns a new bio which represents @sectors from the start of
|
|
|
|
* @bio, and updates @bio to represent the remaining sectors.
|
|
|
|
*
|
2015-07-22 05:57:12 -06:00
|
|
|
* Unless this is a discard request the newly allocated bio will point
|
2019-08-01 16:50:41 -06:00
|
|
|
* to @bio's bi_io_vec. It is the caller's responsibility to ensure that
|
|
|
|
* neither @bio nor @bs are freed before the split bio.
|
2013-11-23 19:21:01 -07:00
|
|
|
*/
|
|
|
|
struct bio *bio_split(struct bio *bio, int sectors,
|
|
|
|
gfp_t gfp, struct bio_set *bs)
|
|
|
|
{
|
2017-11-22 11:18:05 -07:00
|
|
|
struct bio *split;
|
2013-11-23 19:21:01 -07:00
|
|
|
|
|
|
|
BUG_ON(sectors <= 0);
|
|
|
|
BUG_ON(sectors >= bio_sectors(bio));
|
|
|
|
|
2020-05-12 02:55:47 -06:00
|
|
|
/* Zone append commands cannot be split */
|
|
|
|
if (WARN_ON_ONCE(bio_op(bio) == REQ_OP_ZONE_APPEND))
|
|
|
|
return NULL;
|
|
|
|
|
2016-12-08 15:20:32 -07:00
|
|
|
split = bio_clone_fast(bio, gfp, bs);
|
2013-11-23 19:21:01 -07:00
|
|
|
if (!split)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
split->bi_iter.bi_size = sectors << 9;
|
|
|
|
|
|
|
|
if (bio_integrity(split))
|
2017-06-29 12:31:10 -06:00
|
|
|
bio_integrity_trim(split);
|
2013-11-23 19:21:01 -07:00
|
|
|
|
|
|
|
bio_advance(bio, split->bi_iter.bi_size);
|
|
|
|
|
block: trace completion of all bios.
Currently only dm and md/raid5 bios trigger
trace_block_bio_complete(). Now that we have bio_chain() and
bio_inc_remaining(), it is not possible, in general, for a driver to
know when the bio is really complete. Only bio_endio() knows that.
So move the trace_block_bio_complete() call to bio_endio().
Now trace_block_bio_complete() pairs with trace_block_bio_queue().
Any bio for which a 'queue' event is traced, will subsequently
generate a 'complete' event.
There are a few cases where completion tracing is not wanted.
1/ If blk_update_request() has already generated a completion
trace event at the 'request' level, there is no point generating
one at the bio level too. In this case the bi_sector and bi_size
will have changed, so the bio level event would be wrong
2/ If the bio hasn't actually been queued yet, but is being aborted
early, then a trace event could be confusing. Some filesystems
call bio_endio() but do not want tracing.
3/ The bio_integrity code interposes itself by replacing bi_end_io,
then restoring it and calling bio_endio() again. This would produce
two identical trace events if left like that.
To handle these, we introduce a flag BIO_TRACE_COMPLETION and only
produce the trace event when this is set.
We address point 1 above by clearing the flag in blk_update_request().
We address point 2 above by only setting the flag when
generic_make_request() is called.
We address point 3 above by clearing the flag after generating a
completion event.
When bio_split() is used on a bio, particularly in blk_queue_split(),
there is an extra complication. A new bio is split off the front, and
may be handle directly without going through generic_make_request().
The old bio, which has been advanced, is passed to
generic_make_request(), so it will trigger a trace event a second
time.
Probably the best result when a split happens is to see a single
'queue' event for the whole bio, then multiple 'complete' events - one
for each component. To achieve this was can:
- copy the BIO_TRACE_COMPLETION flag to the new bio in bio_split()
- avoid generating a 'queue' event if BIO_TRACE_COMPLETION is already set.
This way, the split-off bio won't create a queue event, the original
won't either even if it re-submitted to generic_make_request(),
but both will produce completion events, each for their own range.
So if generic_make_request() is called (which generates a QUEUED
event), then bi_endio() will create a single COMPLETE event for each
range that the bio is split into, unless the driver has explicitly
requested it not to.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2017-04-07 09:40:52 -06:00
|
|
|
if (bio_flagged(bio, BIO_TRACE_COMPLETION))
|
2018-01-23 09:10:19 -07:00
|
|
|
bio_set_flag(split, BIO_TRACE_COMPLETION);
|
block: trace completion of all bios.
Currently only dm and md/raid5 bios trigger
trace_block_bio_complete(). Now that we have bio_chain() and
bio_inc_remaining(), it is not possible, in general, for a driver to
know when the bio is really complete. Only bio_endio() knows that.
So move the trace_block_bio_complete() call to bio_endio().
Now trace_block_bio_complete() pairs with trace_block_bio_queue().
Any bio for which a 'queue' event is traced, will subsequently
generate a 'complete' event.
There are a few cases where completion tracing is not wanted.
1/ If blk_update_request() has already generated a completion
trace event at the 'request' level, there is no point generating
one at the bio level too. In this case the bi_sector and bi_size
will have changed, so the bio level event would be wrong
2/ If the bio hasn't actually been queued yet, but is being aborted
early, then a trace event could be confusing. Some filesystems
call bio_endio() but do not want tracing.
3/ The bio_integrity code interposes itself by replacing bi_end_io,
then restoring it and calling bio_endio() again. This would produce
two identical trace events if left like that.
To handle these, we introduce a flag BIO_TRACE_COMPLETION and only
produce the trace event when this is set.
We address point 1 above by clearing the flag in blk_update_request().
We address point 2 above by only setting the flag when
generic_make_request() is called.
We address point 3 above by clearing the flag after generating a
completion event.
When bio_split() is used on a bio, particularly in blk_queue_split(),
there is an extra complication. A new bio is split off the front, and
may be handle directly without going through generic_make_request().
The old bio, which has been advanced, is passed to
generic_make_request(), so it will trigger a trace event a second
time.
Probably the best result when a split happens is to see a single
'queue' event for the whole bio, then multiple 'complete' events - one
for each component. To achieve this was can:
- copy the BIO_TRACE_COMPLETION flag to the new bio in bio_split()
- avoid generating a 'queue' event if BIO_TRACE_COMPLETION is already set.
This way, the split-off bio won't create a queue event, the original
won't either even if it re-submitted to generic_make_request(),
but both will produce completion events, each for their own range.
So if generic_make_request() is called (which generates a QUEUED
event), then bi_endio() will create a single COMPLETE event for each
range that the bio is split into, unless the driver has explicitly
requested it not to.
Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
2017-04-07 09:40:52 -06:00
|
|
|
|
2013-11-23 19:21:01 -07:00
|
|
|
return split;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bio_split);
|
|
|
|
|
2013-08-07 12:14:32 -06:00
|
|
|
/**
|
|
|
|
* bio_trim - trim a bio
|
|
|
|
* @bio: bio to trim
|
|
|
|
* @offset: number of sectors to trim from the front of @bio
|
|
|
|
* @size: size we want to trim @bio to, in sectors
|
|
|
|
*/
|
|
|
|
void bio_trim(struct bio *bio, int offset, int size)
|
|
|
|
{
|
|
|
|
/* 'bio' is a cloned bio which we need to trim to match
|
|
|
|
* the given offset and size.
|
|
|
|
*/
|
|
|
|
|
|
|
|
size <<= 9;
|
2013-10-11 16:44:27 -06:00
|
|
|
if (offset == 0 && size == bio->bi_iter.bi_size)
|
2013-08-07 12:14:32 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
bio_advance(bio, offset << 9);
|
2013-10-11 16:44:27 -06:00
|
|
|
bio->bi_iter.bi_size = size;
|
2017-06-29 12:31:08 -06:00
|
|
|
|
|
|
|
if (bio_integrity(bio))
|
2017-06-29 12:31:10 -06:00
|
|
|
bio_integrity_trim(bio);
|
2017-06-29 12:31:08 -06:00
|
|
|
|
2013-08-07 12:14:32 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(bio_trim);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* create memory pools for biovec's in a bio_set.
|
|
|
|
* use the global biovec slabs created for general use.
|
|
|
|
*/
|
2018-05-08 19:33:50 -06:00
|
|
|
int biovec_init_pool(mempool_t *pool, int pool_entries)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2016-07-19 03:28:42 -06:00
|
|
|
struct biovec_slab *bp = bvec_slabs + BVEC_POOL_MAX;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-05-08 19:33:50 -06:00
|
|
|
return mempool_init_slab_pool(pool, pool_entries, bp->slab);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2018-05-08 19:33:51 -06:00
|
|
|
/*
|
|
|
|
* bioset_exit - exit a bioset initialized with bioset_init()
|
|
|
|
*
|
|
|
|
* May be called on a zeroed but uninitialized bioset (i.e. allocated with
|
|
|
|
* kzalloc()).
|
|
|
|
*/
|
|
|
|
void bioset_exit(struct bio_set *bs)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
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 15:33:46 -06:00
|
|
|
if (bs->rescue_workqueue)
|
|
|
|
destroy_workqueue(bs->rescue_workqueue);
|
2018-05-08 19:33:51 -06:00
|
|
|
bs->rescue_workqueue = NULL;
|
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 15:33:46 -06:00
|
|
|
|
2018-05-08 19:33:50 -06:00
|
|
|
mempool_exit(&bs->bio_pool);
|
|
|
|
mempool_exit(&bs->bvec_pool);
|
2012-10-12 16:29:33 -06:00
|
|
|
|
2009-06-26 07:37:49 -06:00
|
|
|
bioset_integrity_free(bs);
|
2018-05-08 19:33:51 -06:00
|
|
|
if (bs->bio_slab)
|
|
|
|
bio_put_slab(bs);
|
|
|
|
bs->bio_slab = NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bioset_exit);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-05-08 19:33:51 -06:00
|
|
|
/**
|
|
|
|
* bioset_init - Initialize a bio_set
|
2018-05-20 16:25:58 -06:00
|
|
|
* @bs: pool to initialize
|
2018-05-08 19:33:51 -06:00
|
|
|
* @pool_size: Number of bio and bio_vecs to cache in the mempool
|
|
|
|
* @front_pad: Number of bytes to allocate in front of the returned bio
|
|
|
|
* @flags: Flags to modify behavior, currently %BIOSET_NEED_BVECS
|
|
|
|
* and %BIOSET_NEED_RESCUER
|
|
|
|
*
|
2018-05-20 16:25:58 -06:00
|
|
|
* Description:
|
|
|
|
* Set up a bio_set to be used with @bio_alloc_bioset. Allows the caller
|
|
|
|
* to ask for a number of bytes to be allocated in front of the bio.
|
|
|
|
* Front pad allocation is useful for embedding the bio inside
|
|
|
|
* another structure, to avoid allocating extra data to go with the bio.
|
|
|
|
* Note that the bio must be embedded at the END of that structure always,
|
|
|
|
* or things will break badly.
|
|
|
|
* If %BIOSET_NEED_BVECS is set in @flags, a separate pool will be allocated
|
|
|
|
* for allocating iovecs. This pool is not needed e.g. for bio_clone_fast().
|
|
|
|
* If %BIOSET_NEED_RESCUER is set, a workqueue is created which can be used to
|
|
|
|
* dispatch queued requests when the mempool runs out of space.
|
|
|
|
*
|
2018-05-08 19:33:51 -06:00
|
|
|
*/
|
|
|
|
int bioset_init(struct bio_set *bs,
|
|
|
|
unsigned int pool_size,
|
|
|
|
unsigned int front_pad,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
unsigned int back_pad = BIO_INLINE_VECS * sizeof(struct bio_vec);
|
|
|
|
|
|
|
|
bs->front_pad = front_pad;
|
|
|
|
|
|
|
|
spin_lock_init(&bs->rescue_lock);
|
|
|
|
bio_list_init(&bs->rescue_list);
|
|
|
|
INIT_WORK(&bs->rescue_work, bio_alloc_rescue);
|
|
|
|
|
|
|
|
bs->bio_slab = bio_find_or_create_slab(front_pad + back_pad);
|
|
|
|
if (!bs->bio_slab)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (mempool_init_slab_pool(&bs->bio_pool, pool_size, bs->bio_slab))
|
|
|
|
goto bad;
|
|
|
|
|
|
|
|
if ((flags & BIOSET_NEED_BVECS) &&
|
|
|
|
biovec_init_pool(&bs->bvec_pool, pool_size))
|
|
|
|
goto bad;
|
|
|
|
|
|
|
|
if (!(flags & BIOSET_NEED_RESCUER))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bs->rescue_workqueue = alloc_workqueue("bioset", WQ_MEM_RECLAIM, 0);
|
|
|
|
if (!bs->rescue_workqueue)
|
|
|
|
goto bad;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
bad:
|
|
|
|
bioset_exit(bs);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bioset_init);
|
|
|
|
|
2018-06-07 14:42:05 -06:00
|
|
|
/*
|
|
|
|
* Initialize and setup a new bio_set, based on the settings from
|
|
|
|
* another bio_set.
|
|
|
|
*/
|
|
|
|
int bioset_init_from_src(struct bio_set *bs, struct bio_set *src)
|
|
|
|
{
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
flags = 0;
|
|
|
|
if (src->bvec_pool.min_nr)
|
|
|
|
flags |= BIOSET_NEED_BVECS;
|
|
|
|
if (src->rescue_workqueue)
|
|
|
|
flags |= BIOSET_NEED_RESCUER;
|
|
|
|
|
|
|
|
return bioset_init(bs, src->bio_pool.min_nr, src->front_pad, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(bioset_init_from_src);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void __init biovec_init_slabs(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2016-07-19 03:28:42 -06:00
|
|
|
for (i = 0; i < BVEC_POOL_NR; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
int size;
|
|
|
|
struct biovec_slab *bvs = bvec_slabs + i;
|
|
|
|
|
2008-12-05 08:10:29 -07:00
|
|
|
if (bvs->nr_vecs <= BIO_INLINE_VECS) {
|
|
|
|
bvs->slab = NULL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
size = bvs->nr_vecs * sizeof(struct bio_vec);
|
|
|
|
bvs->slab = kmem_cache_create(bvs->name, size, 0,
|
2007-07-19 19:11:58 -06:00
|
|
|
SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init init_bio(void)
|
|
|
|
{
|
2008-12-10 07:35:05 -07:00
|
|
|
bio_slab_max = 2;
|
|
|
|
bio_slab_nr = 0;
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 15:03:40 -06:00
|
|
|
bio_slabs = kcalloc(bio_slab_max, sizeof(struct bio_slab),
|
|
|
|
GFP_KERNEL);
|
2019-04-03 03:15:19 -06:00
|
|
|
|
|
|
|
BUILD_BUG_ON(BIO_FLAG_LAST > BVEC_POOL_OFFSET);
|
|
|
|
|
2008-12-10 07:35:05 -07:00
|
|
|
if (!bio_slabs)
|
|
|
|
panic("bio: can't allocate bios\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-26 07:37:49 -06:00
|
|
|
bio_integrity_init();
|
2005-04-16 16:20:36 -06:00
|
|
|
biovec_init_slabs();
|
|
|
|
|
2018-05-08 19:33:52 -06:00
|
|
|
if (bioset_init(&fs_bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS))
|
2005-04-16 16:20:36 -06:00
|
|
|
panic("bio: can't allocate bios\n");
|
|
|
|
|
2018-05-08 19:33:52 -06:00
|
|
|
if (bioset_integrity_create(&fs_bio_set, BIO_POOL_SIZE))
|
2011-03-17 04:11:05 -06:00
|
|
|
panic("bio: can't create integrity pool\n");
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
subsys_initcall(init_bio);
|