2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2003 Sistina Software
|
2007-05-09 09:33:00 +00:00
|
|
|
* Copyright (C) 2006 Red Hat GmbH
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* This file is released under the GPL.
|
|
|
|
*/
|
|
|
|
|
2016-05-12 20:28:10 +00:00
|
|
|
#include "dm-core.h"
|
2009-12-10 23:51:57 +00:00
|
|
|
|
2008-10-21 16:44:59 +00:00
|
|
|
#include <linux/device-mapper.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/bio.h>
|
2014-06-27 19:29:04 +00:00
|
|
|
#include <linux/completion.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
2008-04-24 21:02:01 +00:00
|
|
|
#include <linux/dm-io.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-12-10 23:51:58 +00:00
|
|
|
#define DM_MSG_PREFIX "io"
|
|
|
|
|
|
|
|
#define DM_IO_MAX_REGIONS BITS_PER_LONG
|
|
|
|
|
2007-05-09 09:33:00 +00:00
|
|
|
struct dm_io_client {
|
2018-05-20 22:25:53 +00:00
|
|
|
mempool_t pool;
|
|
|
|
struct bio_set bios;
|
2007-05-09 09:33:00 +00:00
|
|
|
};
|
|
|
|
|
2009-12-10 23:51:58 +00:00
|
|
|
/*
|
|
|
|
* Aligning 'struct io' reduces the number of bits required to store
|
|
|
|
* its address. Refer to store_io_and_region_in_bio() below.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
struct io {
|
2008-04-24 20:43:14 +00:00
|
|
|
unsigned long error_bits;
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_t count;
|
2007-05-09 09:33:00 +00:00
|
|
|
struct dm_io_client *client;
|
2005-04-16 22:20:36 +00:00
|
|
|
io_notify_fn callback;
|
|
|
|
void *context;
|
2011-08-02 11:32:01 +00:00
|
|
|
void *vma_invalidate_address;
|
|
|
|
unsigned long vma_invalidate_size;
|
2009-12-10 23:51:58 +00:00
|
|
|
} __attribute__((aligned(DM_IO_MAX_REGIONS)));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-12-10 23:51:57 +00:00
|
|
|
static struct kmem_cache *_dm_io_cache;
|
|
|
|
|
2007-05-09 09:33:01 +00:00
|
|
|
/*
|
|
|
|
* Create a client with mempool and bioset.
|
|
|
|
*/
|
2011-05-29 12:03:09 +00:00
|
|
|
struct dm_io_client *dm_io_client_create(void)
|
2007-05-09 09:33:01 +00:00
|
|
|
{
|
|
|
|
struct dm_io_client *client;
|
2013-09-12 22:06:12 +00:00
|
|
|
unsigned min_ios = dm_get_reserved_bio_based_ios();
|
2018-05-20 22:25:53 +00:00
|
|
|
int ret;
|
2007-05-09 09:33:01 +00:00
|
|
|
|
2018-06-05 09:26:33 +00:00
|
|
|
client = kzalloc(sizeof(*client), GFP_KERNEL);
|
2007-05-09 09:33:01 +00:00
|
|
|
if (!client)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2018-05-20 22:25:53 +00:00
|
|
|
ret = mempool_init_slab_pool(&client->pool, min_ios, _dm_io_cache);
|
|
|
|
if (ret)
|
2007-05-09 09:33:01 +00:00
|
|
|
goto bad;
|
|
|
|
|
2018-05-20 22:25:53 +00:00
|
|
|
ret = bioset_init(&client->bios, min_ios, 0, BIOSET_NEED_BVECS);
|
|
|
|
if (ret)
|
2007-05-09 09:33:01 +00:00
|
|
|
goto bad;
|
|
|
|
|
|
|
|
return client;
|
|
|
|
|
|
|
|
bad:
|
2018-05-20 22:25:53 +00:00
|
|
|
mempool_exit(&client->pool);
|
2007-05-09 09:33:01 +00:00
|
|
|
kfree(client);
|
2018-05-20 22:25:53 +00:00
|
|
|
return ERR_PTR(ret);
|
2007-05-09 09:33:01 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dm_io_client_create);
|
|
|
|
|
|
|
|
void dm_io_client_destroy(struct dm_io_client *client)
|
|
|
|
{
|
2018-05-20 22:25:53 +00:00
|
|
|
mempool_exit(&client->pool);
|
|
|
|
bioset_exit(&client->bios);
|
2007-05-09 09:33:01 +00:00
|
|
|
kfree(client);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dm_io_client_destroy);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* We need to keep track of which region a bio is doing io for.
|
2009-12-10 23:51:58 +00:00
|
|
|
* To avoid a memory allocation to store just 5 or 6 bits, we
|
|
|
|
* ensure the 'struct io' pointer is aligned so enough low bits are
|
|
|
|
* always zero and then combine it with the region number directly in
|
|
|
|
* bi_private.
|
2005-04-16 22:20:36 +00:00
|
|
|
*---------------------------------------------------------------*/
|
2009-12-10 23:51:58 +00:00
|
|
|
static void store_io_and_region_in_bio(struct bio *bio, struct io *io,
|
|
|
|
unsigned region)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-12-10 23:51:58 +00:00
|
|
|
if (unlikely(!IS_ALIGNED((unsigned long)io, DM_IO_MAX_REGIONS))) {
|
|
|
|
DMCRIT("Unaligned struct io pointer %p", io);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
bio->bi_private = (void *)((unsigned long)io | region);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-12-10 23:51:58 +00:00
|
|
|
static void retrieve_io_and_region_from_bio(struct bio *bio, struct io **io,
|
|
|
|
unsigned *region)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-12-10 23:51:58 +00:00
|
|
|
unsigned long val = (unsigned long)bio->bi_private;
|
|
|
|
|
|
|
|
*io = (void *)(val & -(unsigned long)DM_IO_MAX_REGIONS);
|
|
|
|
*region = val & (DM_IO_MAX_REGIONS - 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* We need an io object to keep track of the number of bios that
|
|
|
|
* have been dispatched for a particular io.
|
|
|
|
*---------------------------------------------------------------*/
|
2014-06-30 17:26:30 +00:00
|
|
|
static void complete_io(struct io *io)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-06-30 17:26:30 +00:00
|
|
|
unsigned long error_bits = io->error_bits;
|
|
|
|
io_notify_fn fn = io->callback;
|
|
|
|
void *context = io->context;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-30 17:26:30 +00:00
|
|
|
if (io->vma_invalidate_size)
|
|
|
|
invalidate_kernel_vmap_range(io->vma_invalidate_address,
|
|
|
|
io->vma_invalidate_size);
|
2011-08-02 11:32:01 +00:00
|
|
|
|
2018-05-20 22:25:53 +00:00
|
|
|
mempool_free(io, &io->client->pool);
|
2014-06-30 17:26:30 +00:00
|
|
|
fn(error_bits, context);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-03 07:38:06 +00:00
|
|
|
static void dec_count(struct io *io, unsigned int region, blk_status_t error)
|
2014-06-30 17:26:30 +00:00
|
|
|
{
|
|
|
|
if (error)
|
|
|
|
set_bit(region, &io->error_bits);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-30 17:26:30 +00:00
|
|
|
if (atomic_dec_and_test(&io->count))
|
|
|
|
complete_io(io);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2015-07-20 13:29:37 +00:00
|
|
|
static void endio(struct bio *bio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-09 09:33:00 +00:00
|
|
|
struct io *io;
|
|
|
|
unsigned region;
|
2017-06-03 07:38:06 +00:00
|
|
|
blk_status_t error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-06-03 07:38:06 +00:00
|
|
|
if (bio->bi_status && bio_data_dir(bio) == READ)
|
2005-04-16 22:20:36 +00:00
|
|
|
zero_fill_bio(bio);
|
|
|
|
|
2007-05-09 09:33:00 +00:00
|
|
|
/*
|
|
|
|
* The bio destructor in bio_put() may use the io object.
|
|
|
|
*/
|
2009-12-10 23:51:58 +00:00
|
|
|
retrieve_io_and_region_from_bio(bio, &io, ®ion);
|
2007-05-09 09:33:00 +00:00
|
|
|
|
2017-06-03 07:38:06 +00:00
|
|
|
error = bio->bi_status;
|
2005-04-16 22:20:36 +00:00
|
|
|
bio_put(bio);
|
|
|
|
|
2015-08-10 23:05:18 +00:00
|
|
|
dec_count(io, region, error);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* These little objects provide an abstraction for getting a new
|
|
|
|
* destination page for io.
|
|
|
|
*---------------------------------------------------------------*/
|
|
|
|
struct dpages {
|
|
|
|
void (*get_page)(struct dpages *dp,
|
|
|
|
struct page **p, unsigned long *len, unsigned *offset);
|
|
|
|
void (*next_page)(struct dpages *dp);
|
|
|
|
|
2016-11-11 12:05:35 +00:00
|
|
|
union {
|
|
|
|
unsigned context_u;
|
|
|
|
struct bvec_iter context_bi;
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
void *context_ptr;
|
2011-08-02 11:32:01 +00:00
|
|
|
|
|
|
|
void *vma_invalidate_address;
|
|
|
|
unsigned long vma_invalidate_size;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functions for getting the pages from a list.
|
|
|
|
*/
|
|
|
|
static void list_get_page(struct dpages *dp,
|
|
|
|
struct page **p, unsigned long *len, unsigned *offset)
|
|
|
|
{
|
|
|
|
unsigned o = dp->context_u;
|
|
|
|
struct page_list *pl = (struct page_list *) dp->context_ptr;
|
|
|
|
|
|
|
|
*p = pl->page;
|
|
|
|
*len = PAGE_SIZE - o;
|
|
|
|
*offset = o;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void list_next_page(struct dpages *dp)
|
|
|
|
{
|
|
|
|
struct page_list *pl = (struct page_list *) dp->context_ptr;
|
|
|
|
dp->context_ptr = pl->next;
|
|
|
|
dp->context_u = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void list_dp_init(struct dpages *dp, struct page_list *pl, unsigned offset)
|
|
|
|
{
|
|
|
|
dp->get_page = list_get_page;
|
|
|
|
dp->next_page = list_next_page;
|
|
|
|
dp->context_u = offset;
|
|
|
|
dp->context_ptr = pl;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functions for getting the pages from a bvec.
|
|
|
|
*/
|
dm io: fix I/O to multiple destinations
Commit 003b5c5719f159f4f4bf97511c4702a0638313dd ("block: Convert drivers
to immutable biovecs") broke dm-mirror due to dm-io breakage.
dm-io had three possible iterators (DM_IO_PAGE_LIST, DM_IO_BVEC,
DM_IO_VMA) that iterate over pages where the I/O should be performed.
The switch to immutable biovecs changed the DM_IO_BVEC iterator to
DM_IO_BIO. Before this change the iterator stored the pointer to a bio
vector in the dpages structure. The iterator incremented the pointer in
the dpages structure as it advanced over the pages. After the immutable
biovecs change, the DM_IO_BIO iterator stores a pointer to the bio in
the dpages structure and uses bio_advance to change the bio as it
advances.
The problem is that the function dispatch_io stores the content of the
dpages structure into the variable old_pages and restores it before
issuing I/O to each of the devices. Before the change, the statement
"*dp = old_pages;" restored the iterator to its starting position.
After the change, struct dpages holds a pointer to the bio, thus the
statement "*dp = old_pages;" doesn't restore the iterator.
Consequently, in the context of dm-mirror: only the first mirror leg is
written correctly, the kernel locks up when trying to write the other
mirror legs because the number of sectors to write in the where->count
variable doesn't match the number of sectors returned by the iterator.
This patch fixes the bug by partially reverting the original patch - it
changes the code so that struct dpages holds a pointer to the bio vector,
so that the statement "*dp = old_pages;" restores the iterator correctly.
The field "context_u" holds the offset from the beginning of the current
bio vector entry, just like the "bio->bi_iter.bi_bvec_done" field.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Mike Snitzer <snitzer@redhat.com>
2014-02-12 21:37:30 +00:00
|
|
|
static void bio_get_page(struct dpages *dp, struct page **p,
|
|
|
|
unsigned long *len, unsigned *offset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-11-11 12:05:35 +00:00
|
|
|
struct bio_vec bvec = bvec_iter_bvec((struct bio_vec *)dp->context_ptr,
|
|
|
|
dp->context_bi);
|
|
|
|
|
|
|
|
*p = bvec.bv_page;
|
|
|
|
*len = bvec.bv_len;
|
|
|
|
*offset = bvec.bv_offset;
|
|
|
|
|
|
|
|
/* avoid figuring it out again in bio_next_page() */
|
|
|
|
dp->context_bi.bi_sector = (sector_t)bvec.bv_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-10-11 22:45:43 +00:00
|
|
|
static void bio_next_page(struct dpages *dp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-11-11 12:05:35 +00:00
|
|
|
unsigned int len = (unsigned int)dp->context_bi.bi_sector;
|
|
|
|
|
|
|
|
bvec_iter_advance((struct bio_vec *)dp->context_ptr,
|
|
|
|
&dp->context_bi, len);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-10-11 22:45:43 +00:00
|
|
|
static void bio_dp_init(struct dpages *dp, struct bio *bio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2013-10-11 22:45:43 +00:00
|
|
|
dp->get_page = bio_get_page;
|
|
|
|
dp->next_page = bio_next_page;
|
2016-11-11 12:05:35 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We just use bvec iterator to retrieve pages, so it is ok to
|
|
|
|
* access the bvec table directly here
|
|
|
|
*/
|
|
|
|
dp->context_ptr = bio->bi_io_vec;
|
|
|
|
dp->context_bi = bio->bi_iter;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-09 09:33:01 +00:00
|
|
|
/*
|
|
|
|
* Functions for getting the pages from a VMA.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
static void vm_get_page(struct dpages *dp,
|
|
|
|
struct page **p, unsigned long *len, unsigned *offset)
|
|
|
|
{
|
|
|
|
*p = vmalloc_to_page(dp->context_ptr);
|
|
|
|
*offset = dp->context_u;
|
|
|
|
*len = PAGE_SIZE - dp->context_u;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vm_next_page(struct dpages *dp)
|
|
|
|
{
|
|
|
|
dp->context_ptr += PAGE_SIZE - dp->context_u;
|
|
|
|
dp->context_u = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vm_dp_init(struct dpages *dp, void *data)
|
|
|
|
{
|
|
|
|
dp->get_page = vm_get_page;
|
|
|
|
dp->next_page = vm_next_page;
|
2016-01-02 18:30:54 +00:00
|
|
|
dp->context_u = offset_in_page(data);
|
2005-04-16 22:20:36 +00:00
|
|
|
dp->context_ptr = data;
|
|
|
|
}
|
|
|
|
|
2007-05-09 09:33:01 +00:00
|
|
|
/*
|
|
|
|
* Functions for getting the pages from kernel memory.
|
|
|
|
*/
|
|
|
|
static void km_get_page(struct dpages *dp, struct page **p, unsigned long *len,
|
|
|
|
unsigned *offset)
|
|
|
|
{
|
|
|
|
*p = virt_to_page(dp->context_ptr);
|
|
|
|
*offset = dp->context_u;
|
|
|
|
*len = PAGE_SIZE - dp->context_u;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void km_next_page(struct dpages *dp)
|
|
|
|
{
|
|
|
|
dp->context_ptr += PAGE_SIZE - dp->context_u;
|
|
|
|
dp->context_u = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void km_dp_init(struct dpages *dp, void *data)
|
|
|
|
{
|
|
|
|
dp->get_page = km_get_page;
|
|
|
|
dp->next_page = km_next_page;
|
2016-01-02 18:30:54 +00:00
|
|
|
dp->context_u = offset_in_page(data);
|
2007-05-09 09:33:01 +00:00
|
|
|
dp->context_ptr = data;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* IO routines that accept a list of pages.
|
|
|
|
*---------------------------------------------------------------*/
|
2016-06-05 19:32:04 +00:00
|
|
|
static void do_region(int op, int op_flags, unsigned region,
|
|
|
|
struct dm_io_region *where, struct dpages *dp,
|
|
|
|
struct io *io)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct bio *bio;
|
|
|
|
struct page *page;
|
|
|
|
unsigned long len;
|
|
|
|
unsigned offset;
|
|
|
|
unsigned num_bvecs;
|
|
|
|
sector_t remaining = where->count;
|
2012-03-07 19:09:37 +00:00
|
|
|
struct request_queue *q = bdev_get_queue(where->bdev);
|
2012-12-21 20:23:37 +00:00
|
|
|
unsigned short logical_block_size = queue_logical_block_size(q);
|
|
|
|
sector_t num_sectors;
|
treewide: Remove uninitialized_var() usage
Using uninitialized_var() is dangerous as it papers over real bugs[1]
(or can in the future), and suppresses unrelated compiler warnings
(e.g. "unused variable"). If the compiler thinks it is uninitialized,
either simply initialize the variable or make compiler changes.
In preparation for removing[2] the[3] macro[4], remove all remaining
needless uses with the following script:
git grep '\buninitialized_var\b' | cut -d: -f1 | sort -u | \
xargs perl -pi -e \
's/\buninitialized_var\(([^\)]+)\)/\1/g;
s:\s*/\* (GCC be quiet|to make compiler happy) \*/$::g;'
drivers/video/fbdev/riva/riva_hw.c was manually tweaked to avoid
pathological white-space.
No outstanding warnings were found building allmodconfig with GCC 9.3.0
for x86_64, i386, arm64, arm, powerpc, powerpc64le, s390x, mips, sparc64,
alpha, and m68k.
[1] https://lore.kernel.org/lkml/20200603174714.192027-1-glider@google.com/
[2] https://lore.kernel.org/lkml/CA+55aFw+Vbj0i=1TGqCR5vQkCzWJ0QxK6CernOU6eedsudAixw@mail.gmail.com/
[3] https://lore.kernel.org/lkml/CA+55aFwgbgqhbp1fkxvRKEpzyR5J8n1vKT1VZdz9knmPuXhOeg@mail.gmail.com/
[4] https://lore.kernel.org/lkml/CA+55aFz2500WfbKXAx8s67wrm9=yVJu65TpLgN_ybYNv0VEOKA@mail.gmail.com/
Reviewed-by: Leon Romanovsky <leonro@mellanox.com> # drivers/infiniband and mlx4/mlx5
Acked-by: Jason Gunthorpe <jgg@mellanox.com> # IB
Acked-by: Kalle Valo <kvalo@codeaurora.org> # wireless drivers
Reviewed-by: Chao Yu <yuchao0@huawei.com> # erofs
Signed-off-by: Kees Cook <keescook@chromium.org>
2020-06-03 20:09:38 +00:00
|
|
|
unsigned int special_cmd_max_sectors;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-02-27 18:44:38 +00:00
|
|
|
/*
|
|
|
|
* Reject unsupported discard and write same requests.
|
|
|
|
*/
|
2016-06-05 19:32:04 +00:00
|
|
|
if (op == REQ_OP_DISCARD)
|
2015-02-27 18:44:38 +00:00
|
|
|
special_cmd_max_sectors = q->limits.max_discard_sectors;
|
2017-04-05 17:21:05 +00:00
|
|
|
else if (op == REQ_OP_WRITE_ZEROES)
|
|
|
|
special_cmd_max_sectors = q->limits.max_write_zeroes_sectors;
|
2016-06-05 19:32:04 +00:00
|
|
|
else if (op == REQ_OP_WRITE_SAME)
|
2015-02-27 18:44:38 +00:00
|
|
|
special_cmd_max_sectors = q->limits.max_write_same_sectors;
|
2017-04-05 17:21:05 +00:00
|
|
|
if ((op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES ||
|
2017-06-20 23:14:30 +00:00
|
|
|
op == REQ_OP_WRITE_SAME) && special_cmd_max_sectors == 0) {
|
|
|
|
atomic_inc(&io->count);
|
2017-06-03 07:38:06 +00:00
|
|
|
dec_count(io, region, BLK_STS_NOTSUPP);
|
2015-02-13 19:05:37 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-12-10 23:52:22 +00:00
|
|
|
/*
|
2016-06-05 19:32:04 +00:00
|
|
|
* where->count may be zero if op holds a flush and we need to
|
2010-09-03 09:56:19 +00:00
|
|
|
* send a zero-sized flush.
|
2009-12-10 23:52:22 +00:00
|
|
|
*/
|
|
|
|
do {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2009-12-10 23:51:58 +00:00
|
|
|
* Allocate a suitably sized-bio.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2017-04-05 17:21:04 +00:00
|
|
|
switch (op) {
|
|
|
|
case REQ_OP_DISCARD:
|
2017-04-05 17:21:05 +00:00
|
|
|
case REQ_OP_WRITE_ZEROES:
|
2017-04-05 17:21:04 +00:00
|
|
|
num_bvecs = 0;
|
|
|
|
break;
|
|
|
|
case REQ_OP_WRITE_SAME:
|
2012-03-07 19:09:37 +00:00
|
|
|
num_bvecs = 1;
|
2017-04-05 17:21:04 +00:00
|
|
|
break;
|
|
|
|
default:
|
2021-01-29 04:38:57 +00:00
|
|
|
num_bvecs = bio_max_segs(dm_sector_div_up(remaining,
|
|
|
|
(PAGE_SIZE >> SECTOR_SHIFT)));
|
2017-04-05 17:21:04 +00:00
|
|
|
}
|
2012-03-07 19:09:37 +00:00
|
|
|
|
2018-05-20 22:25:53 +00:00
|
|
|
bio = bio_alloc_bioset(GFP_NOIO, num_bvecs, &io->client->bios);
|
2013-10-11 22:44:27 +00:00
|
|
|
bio->bi_iter.bi_sector = where->sector + (where->count - remaining);
|
2017-08-23 17:10:32 +00:00
|
|
|
bio_set_dev(bio, where->bdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
bio->bi_end_io = endio;
|
2016-06-05 19:32:04 +00:00
|
|
|
bio_set_op_attrs(bio, op, op_flags);
|
2009-12-10 23:51:58 +00:00
|
|
|
store_io_and_region_in_bio(bio, io, region);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-04-05 17:21:05 +00:00
|
|
|
if (op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES) {
|
2015-02-27 18:44:38 +00:00
|
|
|
num_sectors = min_t(sector_t, special_cmd_max_sectors, remaining);
|
2013-10-11 22:44:27 +00:00
|
|
|
bio->bi_iter.bi_size = num_sectors << SECTOR_SHIFT;
|
2012-12-21 20:23:37 +00:00
|
|
|
remaining -= num_sectors;
|
2016-06-05 19:32:04 +00:00
|
|
|
} else if (op == REQ_OP_WRITE_SAME) {
|
2012-12-21 20:23:37 +00:00
|
|
|
/*
|
|
|
|
* WRITE SAME only uses a single page.
|
|
|
|
*/
|
|
|
|
dp->get_page(dp, &page, &len, &offset);
|
|
|
|
bio_add_page(bio, page, logical_block_size, offset);
|
2015-02-27 18:44:38 +00:00
|
|
|
num_sectors = min_t(sector_t, special_cmd_max_sectors, remaining);
|
2013-10-11 22:44:27 +00:00
|
|
|
bio->bi_iter.bi_size = num_sectors << SECTOR_SHIFT;
|
2012-12-21 20:23:37 +00:00
|
|
|
|
|
|
|
offset = 0;
|
|
|
|
remaining -= num_sectors;
|
|
|
|
dp->next_page(dp);
|
2012-03-07 19:09:37 +00:00
|
|
|
} else while (remaining) {
|
|
|
|
/*
|
|
|
|
* Try and add as many pages as possible.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
dp->get_page(dp, &page, &len, &offset);
|
|
|
|
len = min(len, to_bytes(remaining));
|
|
|
|
if (!bio_add_page(bio, page, len, offset))
|
|
|
|
break;
|
|
|
|
|
|
|
|
offset = 0;
|
|
|
|
remaining -= to_sector(len);
|
|
|
|
dp->next_page(dp);
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_inc(&io->count);
|
2016-06-05 19:31:41 +00:00
|
|
|
submit_bio(bio);
|
2009-12-10 23:52:22 +00:00
|
|
|
} while (remaining);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2016-06-05 19:32:04 +00:00
|
|
|
static void dispatch_io(int op, int op_flags, unsigned int num_regions,
|
2008-04-24 20:43:17 +00:00
|
|
|
struct dm_io_region *where, struct dpages *dp,
|
2005-04-16 22:20:36 +00:00
|
|
|
struct io *io, int sync)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct dpages old_pages = *dp;
|
|
|
|
|
2009-12-10 23:51:58 +00:00
|
|
|
BUG_ON(num_regions > DM_IO_MAX_REGIONS);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sync)
|
2016-06-05 19:32:04 +00:00
|
|
|
op_flags |= REQ_SYNC;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For multiple regions we need to be careful to rewind
|
|
|
|
* the dp object for each call to do_region.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < num_regions; i++) {
|
|
|
|
*dp = old_pages;
|
2016-06-05 19:32:25 +00:00
|
|
|
if (where[i].count || (op_flags & REQ_PREFLUSH))
|
2016-06-05 19:32:04 +00:00
|
|
|
do_region(op, op_flags, i, where + i, dp, io);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-12-08 10:41:01 +00:00
|
|
|
* Drop the extra reference that we were holding to avoid
|
2005-04-16 22:20:36 +00:00
|
|
|
* the io being completed too early.
|
|
|
|
*/
|
|
|
|
dec_count(io, 0, 0);
|
|
|
|
}
|
|
|
|
|
2014-06-30 17:26:30 +00:00
|
|
|
struct sync_io {
|
|
|
|
unsigned long error_bits;
|
|
|
|
struct completion wait;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void sync_io_complete(unsigned long error, void *context)
|
|
|
|
{
|
|
|
|
struct sync_io *sio = context;
|
|
|
|
|
|
|
|
sio->error_bits = error;
|
|
|
|
complete(&sio->wait);
|
|
|
|
}
|
|
|
|
|
2007-05-09 09:33:00 +00:00
|
|
|
static int sync_io(struct dm_io_client *client, unsigned int num_regions,
|
2016-06-05 19:32:04 +00:00
|
|
|
struct dm_io_region *where, int op, int op_flags,
|
|
|
|
struct dpages *dp, unsigned long *error_bits)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-06-30 17:26:30 +00:00
|
|
|
struct io *io;
|
|
|
|
struct sync_io sio;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-06-05 19:32:04 +00:00
|
|
|
if (num_regions > 1 && !op_is_write(op)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
WARN_ON(1);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2014-06-30 17:26:30 +00:00
|
|
|
init_completion(&sio.wait);
|
|
|
|
|
2018-05-20 22:25:53 +00:00
|
|
|
io = mempool_alloc(&client->pool, GFP_NOIO);
|
2009-12-10 23:51:58 +00:00
|
|
|
io->error_bits = 0;
|
|
|
|
atomic_set(&io->count, 1); /* see dispatch_io() */
|
|
|
|
io->client = client;
|
2014-06-30 17:26:30 +00:00
|
|
|
io->callback = sync_io_complete;
|
|
|
|
io->context = &sio;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-02 11:32:01 +00:00
|
|
|
io->vma_invalidate_address = dp->vma_invalidate_address;
|
|
|
|
io->vma_invalidate_size = dp->vma_invalidate_size;
|
|
|
|
|
2016-06-05 19:32:04 +00:00
|
|
|
dispatch_io(op, op_flags, num_regions, where, dp, io, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-30 17:26:30 +00:00
|
|
|
wait_for_completion_io(&sio.wait);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-09 09:33:00 +00:00
|
|
|
if (error_bits)
|
2014-06-30 17:26:30 +00:00
|
|
|
*error_bits = sio.error_bits;
|
2007-05-09 09:33:00 +00:00
|
|
|
|
2014-06-30 17:26:30 +00:00
|
|
|
return sio.error_bits ? -EIO : 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-09 09:33:00 +00:00
|
|
|
static int async_io(struct dm_io_client *client, unsigned int num_regions,
|
2016-06-05 19:32:04 +00:00
|
|
|
struct dm_io_region *where, int op, int op_flags,
|
|
|
|
struct dpages *dp, io_notify_fn fn, void *context)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct io *io;
|
|
|
|
|
2016-06-05 19:32:04 +00:00
|
|
|
if (num_regions > 1 && !op_is_write(op)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
WARN_ON(1);
|
|
|
|
fn(1, context);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2018-05-20 22:25:53 +00:00
|
|
|
io = mempool_alloc(&client->pool, GFP_NOIO);
|
2008-04-24 20:43:14 +00:00
|
|
|
io->error_bits = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_set(&io->count, 1); /* see dispatch_io() */
|
2007-05-09 09:33:00 +00:00
|
|
|
io->client = client;
|
2005-04-16 22:20:36 +00:00
|
|
|
io->callback = fn;
|
|
|
|
io->context = context;
|
|
|
|
|
2011-08-02 11:32:01 +00:00
|
|
|
io->vma_invalidate_address = dp->vma_invalidate_address;
|
|
|
|
io->vma_invalidate_size = dp->vma_invalidate_size;
|
|
|
|
|
2016-06-05 19:32:04 +00:00
|
|
|
dispatch_io(op, op_flags, num_regions, where, dp, io, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-02 11:32:01 +00:00
|
|
|
static int dp_init(struct dm_io_request *io_req, struct dpages *dp,
|
|
|
|
unsigned long size)
|
2007-05-09 09:33:01 +00:00
|
|
|
{
|
|
|
|
/* Set up dpages based on memory type */
|
2011-08-02 11:32:01 +00:00
|
|
|
|
|
|
|
dp->vma_invalidate_address = NULL;
|
|
|
|
dp->vma_invalidate_size = 0;
|
|
|
|
|
2007-05-09 09:33:01 +00:00
|
|
|
switch (io_req->mem.type) {
|
|
|
|
case DM_IO_PAGE_LIST:
|
|
|
|
list_dp_init(dp, io_req->mem.ptr.pl, io_req->mem.offset);
|
|
|
|
break;
|
|
|
|
|
2013-10-11 22:45:43 +00:00
|
|
|
case DM_IO_BIO:
|
|
|
|
bio_dp_init(dp, io_req->mem.ptr.bio);
|
2007-05-09 09:33:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case DM_IO_VMA:
|
2011-08-02 11:32:01 +00:00
|
|
|
flush_kernel_vmap_range(io_req->mem.ptr.vma, size);
|
2016-06-05 19:32:04 +00:00
|
|
|
if (io_req->bi_op == REQ_OP_READ) {
|
2011-08-02 11:32:01 +00:00
|
|
|
dp->vma_invalidate_address = io_req->mem.ptr.vma;
|
|
|
|
dp->vma_invalidate_size = size;
|
|
|
|
}
|
2007-05-09 09:33:01 +00:00
|
|
|
vm_dp_init(dp, io_req->mem.ptr.vma);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DM_IO_KMEM:
|
|
|
|
km_dp_init(dp, io_req->mem.ptr.addr);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
dm: unplug queues in threads
Remove an avoidable 3ms delay on some dm-raid1 and kcopyd I/O.
It is specified that any submitted bio without BIO_RW_SYNC flag may plug the
queue (i.e. block the requests from being dispatched to the physical device).
The queue is unplugged when the caller calls blk_unplug() function. Usually, the
sequence is that someone calls submit_bh to submit IO on a buffer. The IO plugs
the queue and waits (to be possibly joined with other adjacent bios). Then, when
the caller calls wait_on_buffer(), it unplugs the queue and submits the IOs to
the disk.
This was happenning:
When doing O_SYNC writes, function fsync_buffers_list() submits a list of
bios to dm_raid1, the bios are added to dm_raid1 write queue and kmirrord is
woken up.
fsync_buffers_list() calls wait_on_buffer(). That unplugs the queue, but
there are no bios on the device queue as they are still in the dm_raid1 queue.
wait_on_buffer() starts waiting until the IO is finished.
kmirrord is scheduled, kmirrord takes bios and submits them to the devices.
The submitted bio plugs the harddisk queue but there is no one to unplug it.
(The process that called wait_on_buffer() is already sleeping.)
So there is a 3ms timeout, after which the queues on the harddisks are
unplugged and requests are processed.
This 3ms timeout meant that in certain workloads (e.g. O_SYNC, 8kb writes),
dm-raid1 is 10 times slower than md raid1.
Every time we submit something asynchronously via dm_io, we must unplug the
queue actually to send the request to the device.
This patch adds an unplug call to kmirrord - while processing requests, it keeps
the queue plugged (so that adjacent bios can be merged); when it finishes
processing all the bios, it unplugs the queue to submit the bios.
It also fixes kcopyd which has the same potential problem. All kcopyd requests
are submitted with BIO_RW_SYNC.
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Acked-by: Jens Axboe <jens.axboe@oracle.com>
2008-04-24 21:10:47 +00:00
|
|
|
* New collapsed (a)synchronous interface.
|
|
|
|
*
|
|
|
|
* If the IO is asynchronous (i.e. it has notify.fn), you must either unplug
|
2016-08-05 21:35:16 +00:00
|
|
|
* the queue with blk_unplug() some time later or set REQ_SYNC in
|
|
|
|
* io_req->bi_opf. If you fail to do one of these, the IO will be submitted to
|
|
|
|
* the disk after q->unplug_delay, which defaults to 3ms in blk-settings.c.
|
2007-05-09 09:33:01 +00:00
|
|
|
*/
|
|
|
|
int dm_io(struct dm_io_request *io_req, unsigned num_regions,
|
2008-04-24 20:43:17 +00:00
|
|
|
struct dm_io_region *where, unsigned long *sync_error_bits)
|
2007-05-09 09:33:01 +00:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
struct dpages dp;
|
|
|
|
|
2011-08-02 11:32:01 +00:00
|
|
|
r = dp_init(io_req, &dp, (unsigned long)where->count << SECTOR_SHIFT);
|
2007-05-09 09:33:01 +00:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (!io_req->notify.fn)
|
|
|
|
return sync_io(io_req->client, num_regions, where,
|
2016-06-05 19:32:04 +00:00
|
|
|
io_req->bi_op, io_req->bi_op_flags, &dp,
|
|
|
|
sync_error_bits);
|
2007-05-09 09:33:01 +00:00
|
|
|
|
2016-06-05 19:32:04 +00:00
|
|
|
return async_io(io_req->client, num_regions, where, io_req->bi_op,
|
|
|
|
io_req->bi_op_flags, &dp, io_req->notify.fn,
|
|
|
|
io_req->notify.context);
|
2007-05-09 09:33:01 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dm_io);
|
2009-12-10 23:51:57 +00:00
|
|
|
|
|
|
|
int __init dm_io_init(void)
|
|
|
|
{
|
|
|
|
_dm_io_cache = KMEM_CACHE(io, 0);
|
|
|
|
if (!_dm_io_cache)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void dm_io_exit(void)
|
|
|
|
{
|
|
|
|
kmem_cache_destroy(_dm_io_cache);
|
|
|
|
_dm_io_cache = NULL;
|
|
|
|
}
|