2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2001, 2002 Sistina Software (UK) Limited.
|
2009-01-06 03:05:12 +00:00
|
|
|
* Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* This file is released under the GPL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "dm.h"
|
2007-10-19 21:48:00 +00:00
|
|
|
#include "dm-uevent.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/module.h>
|
2006-03-27 09:18:20 +00:00
|
|
|
#include <linux/mutex.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/blkpg.h>
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/mempool.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/idr.h>
|
2006-03-27 09:17:54 +00:00
|
|
|
#include <linux/hdreg.h>
|
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-09 05:43:05 +00:00
|
|
|
|
|
|
|
#include <trace/events/block.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-26 07:27:35 +00:00
|
|
|
#define DM_MSG_PREFIX "core"
|
|
|
|
|
2009-06-22 09:12:30 +00:00
|
|
|
/*
|
|
|
|
* Cookies are numeric values sent with CHANGE and REMOVE
|
|
|
|
* uevents while resuming, removing or renaming the device.
|
|
|
|
*/
|
|
|
|
#define DM_COOKIE_ENV_VAR_NAME "DM_COOKIE"
|
|
|
|
#define DM_COOKIE_LENGTH 24
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static const char *_name = DM_NAME;
|
|
|
|
|
|
|
|
static unsigned int major = 0;
|
|
|
|
static unsigned int _major = 0;
|
|
|
|
|
2006-06-26 07:27:22 +00:00
|
|
|
static DEFINE_SPINLOCK(_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2009-01-06 03:05:06 +00:00
|
|
|
* For bio-based dm.
|
2005-04-16 22:20:36 +00:00
|
|
|
* One of these is allocated per bio.
|
|
|
|
*/
|
|
|
|
struct dm_io {
|
|
|
|
struct mapped_device *md;
|
|
|
|
int error;
|
|
|
|
atomic_t io_count;
|
2008-07-21 11:00:28 +00:00
|
|
|
struct bio *bio;
|
2006-02-01 11:04:53 +00:00
|
|
|
unsigned long start_time;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2009-01-06 03:05:06 +00:00
|
|
|
* For bio-based dm.
|
2005-04-16 22:20:36 +00:00
|
|
|
* One of these is allocated per target within a bio. Hopefully
|
|
|
|
* this will be simplified out one day.
|
|
|
|
*/
|
2007-07-12 16:26:32 +00:00
|
|
|
struct dm_target_io {
|
2005-04-16 22:20:36 +00:00
|
|
|
struct dm_io *io;
|
|
|
|
struct dm_target *ti;
|
|
|
|
union map_info info;
|
|
|
|
};
|
|
|
|
|
2009-01-06 03:05:06 +00:00
|
|
|
/*
|
|
|
|
* For request-based dm.
|
|
|
|
* One of these is allocated per request.
|
|
|
|
*/
|
|
|
|
struct dm_rq_target_io {
|
|
|
|
struct mapped_device *md;
|
|
|
|
struct dm_target *ti;
|
|
|
|
struct request *orig, clone;
|
|
|
|
int error;
|
|
|
|
union map_info info;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For request-based dm.
|
|
|
|
* One of these is allocated per bio.
|
|
|
|
*/
|
|
|
|
struct dm_rq_clone_bio_info {
|
|
|
|
struct bio *orig;
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
struct dm_rq_target_io *tio;
|
2009-01-06 03:05:06 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
union map_info *dm_get_mapinfo(struct bio *bio)
|
|
|
|
{
|
2006-06-26 07:27:33 +00:00
|
|
|
if (bio && bio->bi_private)
|
2007-07-12 16:26:32 +00:00
|
|
|
return &((struct dm_target_io *)bio->bi_private)->info;
|
2006-06-26 07:27:33 +00:00
|
|
|
return NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
union map_info *dm_get_rq_mapinfo(struct request *rq)
|
|
|
|
{
|
|
|
|
if (rq && rq->end_io_data)
|
|
|
|
return &((struct dm_rq_target_io *)rq->end_io_data)->info;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dm_get_rq_mapinfo);
|
|
|
|
|
2006-06-26 07:27:21 +00:00
|
|
|
#define MINOR_ALLOCED ((void *)-1)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Bits for the md->flags field.
|
|
|
|
*/
|
2009-04-08 23:27:14 +00:00
|
|
|
#define DMF_BLOCK_IO_FOR_SUSPEND 0
|
2005-04-16 22:20:36 +00:00
|
|
|
#define DMF_SUSPENDED 1
|
2006-01-06 08:20:06 +00:00
|
|
|
#define DMF_FROZEN 2
|
2006-06-26 07:27:23 +00:00
|
|
|
#define DMF_FREEING 3
|
2006-06-26 07:27:34 +00:00
|
|
|
#define DMF_DELETING 4
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
#define DMF_NOFLUSH_SUSPENDING 5
|
2009-04-08 23:27:14 +00:00
|
|
|
#define DMF_QUEUE_IO_TO_THREAD 6
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 02:11:17 +00:00
|
|
|
/*
|
|
|
|
* Work processed by per-device workqueue.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
struct mapped_device {
|
2005-07-29 04:16:00 +00:00
|
|
|
struct rw_semaphore io_lock;
|
2008-02-08 02:10:08 +00:00
|
|
|
struct mutex suspend_lock;
|
2005-04-16 22:20:36 +00:00
|
|
|
rwlock_t map_lock;
|
|
|
|
atomic_t holders;
|
2006-06-26 07:27:34 +00:00
|
|
|
atomic_t open_count;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
struct request_queue *queue;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct gendisk *disk;
|
2006-03-27 09:17:52 +00:00
|
|
|
char name[16];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
void *interface_ptr;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A list of ios that arrived while we were suspended.
|
|
|
|
*/
|
Revert "Seperate read and write statistics of in_flight requests"
This reverts commit a9327cac440be4d8333bba975cbbf76045096275.
Corrado Zoccolo <czoccolo@gmail.com> reports:
"with 2.6.32-rc1 I started getting the following strange output from
"iostat -kx 2":
Linux 2.6.31bisect (et2) 04/10/2009 _i686_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
10,70 0,00 3,16 15,75 0,00 70,38
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 18,22 0,00 0,67 0,01 14,77 0,02
43,94 0,01 10,53 39043915,03 2629219,87
sdb 60,89 9,68 50,79 3,04 1724,43 50,52
65,95 0,70 13,06 488437,47 2629219,87
avg-cpu: %user %nice %system %iowait %steal %idle
2,72 0,00 0,74 0,00 0,00 96,53
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
6,68 0,00 0,99 0,00 0,00 92,33
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
4,40 0,00 0,73 1,47 0,00 93,40
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 4,00 0,00 3,00 0,00 28,00
18,67 0,06 19,50 333,33 100,00
Global values for service time and utilization are garbage. For
interval values, utilization is always 100%, and service time is
higher than normal.
I bisected it down to:
[a9327cac440be4d8333bba975cbbf76045096275] Seperate read and write
statistics of in_flight requests
and verified that reverting just that commit indeed solves the issue
on 2.6.32-rc1."
So until this is debugged, revert the bad commit.
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2009-10-04 19:04:38 +00:00
|
|
|
atomic_t pending;
|
2005-04-16 22:20:36 +00:00
|
|
|
wait_queue_head_t wait;
|
2009-04-02 18:55:37 +00:00
|
|
|
struct work_struct work;
|
2006-12-08 10:41:02 +00:00
|
|
|
struct bio_list deferred;
|
2009-04-02 18:55:39 +00:00
|
|
|
spinlock_t deferred_lock;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:16 +00:00
|
|
|
/*
|
|
|
|
* An error from the barrier request currently being processed.
|
|
|
|
*/
|
|
|
|
int barrier_error;
|
|
|
|
|
2008-02-08 02:11:17 +00:00
|
|
|
/*
|
|
|
|
* Processing queue (flush/barriers)
|
|
|
|
*/
|
|
|
|
struct workqueue_struct *wq;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The current mapping.
|
|
|
|
*/
|
|
|
|
struct dm_table *map;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* io objects are allocated from here.
|
|
|
|
*/
|
|
|
|
mempool_t *io_pool;
|
|
|
|
mempool_t *tio_pool;
|
|
|
|
|
2006-10-03 08:15:41 +00:00
|
|
|
struct bio_set *bs;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Event handling.
|
|
|
|
*/
|
|
|
|
atomic_t event_nr;
|
|
|
|
wait_queue_head_t eventq;
|
2007-10-19 21:48:01 +00:00
|
|
|
atomic_t uevent_seq;
|
|
|
|
struct list_head uevent_list;
|
|
|
|
spinlock_t uevent_lock; /* Protect access to uevent_list */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* freeze/thaw support require holding onto a super block
|
|
|
|
*/
|
|
|
|
struct super_block *frozen_sb;
|
2009-06-22 09:12:15 +00:00
|
|
|
struct block_device *bdev;
|
2006-03-27 09:17:54 +00:00
|
|
|
|
|
|
|
/* forced geometry settings */
|
|
|
|
struct hd_geometry geometry;
|
2009-01-06 03:05:12 +00:00
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
/* marker of flush suspend for request-based dm */
|
|
|
|
struct request suspend_rq;
|
|
|
|
|
|
|
|
/* For saving the address of __make_request for request based dm */
|
|
|
|
make_request_fn *saved_make_request_fn;
|
|
|
|
|
2009-01-06 03:05:12 +00:00
|
|
|
/* sysfs handle */
|
|
|
|
struct kobject kobj;
|
2009-06-22 09:12:21 +00:00
|
|
|
|
|
|
|
/* zero-length barrier that will be cloned and submitted to targets */
|
|
|
|
struct bio barrier_bio;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
/*
|
|
|
|
* For mempools pre-allocation at the table loading time.
|
|
|
|
*/
|
|
|
|
struct dm_md_mempools {
|
|
|
|
mempool_t *io_pool;
|
|
|
|
mempool_t *tio_pool;
|
|
|
|
struct bio_set *bs;
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define MIN_IOS 256
|
2006-12-07 04:33:20 +00:00
|
|
|
static struct kmem_cache *_io_cache;
|
|
|
|
static struct kmem_cache *_tio_cache;
|
2009-01-06 03:05:06 +00:00
|
|
|
static struct kmem_cache *_rq_tio_cache;
|
|
|
|
static struct kmem_cache *_rq_bio_info_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int __init local_init(void)
|
|
|
|
{
|
2008-10-21 16:45:08 +00:00
|
|
|
int r = -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* allocate a slab for the dm_ios */
|
2007-07-12 16:26:32 +00:00
|
|
|
_io_cache = KMEM_CACHE(dm_io, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!_io_cache)
|
2008-10-21 16:45:08 +00:00
|
|
|
return r;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* allocate a slab for the target ios */
|
2007-07-12 16:26:32 +00:00
|
|
|
_tio_cache = KMEM_CACHE(dm_target_io, 0);
|
2008-10-21 16:45:08 +00:00
|
|
|
if (!_tio_cache)
|
|
|
|
goto out_free_io_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-01-06 03:05:06 +00:00
|
|
|
_rq_tio_cache = KMEM_CACHE(dm_rq_target_io, 0);
|
|
|
|
if (!_rq_tio_cache)
|
|
|
|
goto out_free_tio_cache;
|
|
|
|
|
|
|
|
_rq_bio_info_cache = KMEM_CACHE(dm_rq_clone_bio_info, 0);
|
|
|
|
if (!_rq_bio_info_cache)
|
|
|
|
goto out_free_rq_tio_cache;
|
|
|
|
|
2007-10-19 21:48:00 +00:00
|
|
|
r = dm_uevent_init();
|
2008-10-21 16:45:08 +00:00
|
|
|
if (r)
|
2009-01-06 03:05:06 +00:00
|
|
|
goto out_free_rq_bio_info_cache;
|
2007-10-19 21:48:00 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
_major = major;
|
|
|
|
r = register_blkdev(_major, _name);
|
2008-10-21 16:45:08 +00:00
|
|
|
if (r < 0)
|
|
|
|
goto out_uevent_exit;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!_major)
|
|
|
|
_major = r;
|
|
|
|
|
|
|
|
return 0;
|
2008-10-21 16:45:08 +00:00
|
|
|
|
|
|
|
out_uevent_exit:
|
|
|
|
dm_uevent_exit();
|
2009-01-06 03:05:06 +00:00
|
|
|
out_free_rq_bio_info_cache:
|
|
|
|
kmem_cache_destroy(_rq_bio_info_cache);
|
|
|
|
out_free_rq_tio_cache:
|
|
|
|
kmem_cache_destroy(_rq_tio_cache);
|
2008-10-21 16:45:08 +00:00
|
|
|
out_free_tio_cache:
|
|
|
|
kmem_cache_destroy(_tio_cache);
|
|
|
|
out_free_io_cache:
|
|
|
|
kmem_cache_destroy(_io_cache);
|
|
|
|
|
|
|
|
return r;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void local_exit(void)
|
|
|
|
{
|
2009-01-06 03:05:06 +00:00
|
|
|
kmem_cache_destroy(_rq_bio_info_cache);
|
|
|
|
kmem_cache_destroy(_rq_tio_cache);
|
2005-04-16 22:20:36 +00:00
|
|
|
kmem_cache_destroy(_tio_cache);
|
|
|
|
kmem_cache_destroy(_io_cache);
|
2007-07-17 11:03:46 +00:00
|
|
|
unregister_blkdev(_major, _name);
|
2007-10-19 21:48:00 +00:00
|
|
|
dm_uevent_exit();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
_major = 0;
|
|
|
|
|
|
|
|
DMINFO("cleaned up");
|
|
|
|
}
|
|
|
|
|
2008-02-08 02:09:51 +00:00
|
|
|
static int (*_inits[])(void) __initdata = {
|
2005-04-16 22:20:36 +00:00
|
|
|
local_init,
|
|
|
|
dm_target_init,
|
|
|
|
dm_linear_init,
|
|
|
|
dm_stripe_init,
|
2008-04-24 20:43:49 +00:00
|
|
|
dm_kcopyd_init,
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_interface_init,
|
|
|
|
};
|
|
|
|
|
2008-02-08 02:09:51 +00:00
|
|
|
static void (*_exits[])(void) = {
|
2005-04-16 22:20:36 +00:00
|
|
|
local_exit,
|
|
|
|
dm_target_exit,
|
|
|
|
dm_linear_exit,
|
|
|
|
dm_stripe_exit,
|
2008-04-24 20:43:49 +00:00
|
|
|
dm_kcopyd_exit,
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_interface_exit,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init dm_init(void)
|
|
|
|
{
|
|
|
|
const int count = ARRAY_SIZE(_inits);
|
|
|
|
|
|
|
|
int r, i;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
r = _inits[i]();
|
|
|
|
if (r)
|
|
|
|
goto bad;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
while (i--)
|
|
|
|
_exits[i]();
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit dm_exit(void)
|
|
|
|
{
|
|
|
|
int i = ARRAY_SIZE(_exits);
|
|
|
|
|
|
|
|
while (i--)
|
|
|
|
_exits[i]();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Block device functions
|
|
|
|
*/
|
2008-03-02 15:29:31 +00:00
|
|
|
static int dm_blk_open(struct block_device *bdev, fmode_t mode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct mapped_device *md;
|
|
|
|
|
2006-06-26 07:27:23 +00:00
|
|
|
spin_lock(&_minor_lock);
|
|
|
|
|
2008-03-02 15:29:31 +00:00
|
|
|
md = bdev->bd_disk->private_data;
|
2006-06-26 07:27:23 +00:00
|
|
|
if (!md)
|
|
|
|
goto out;
|
|
|
|
|
2006-06-26 07:27:34 +00:00
|
|
|
if (test_bit(DMF_FREEING, &md->flags) ||
|
|
|
|
test_bit(DMF_DELETING, &md->flags)) {
|
2006-06-26 07:27:23 +00:00
|
|
|
md = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_get(md);
|
2006-06-26 07:27:34 +00:00
|
|
|
atomic_inc(&md->open_count);
|
2006-06-26 07:27:23 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&_minor_lock);
|
|
|
|
|
|
|
|
return md ? 0 : -ENXIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-03-02 15:29:31 +00:00
|
|
|
static int dm_blk_close(struct gendisk *disk, fmode_t mode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-03-02 15:29:31 +00:00
|
|
|
struct mapped_device *md = disk->private_data;
|
2006-06-26 07:27:34 +00:00
|
|
|
atomic_dec(&md->open_count);
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_put(md);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:27:34 +00:00
|
|
|
int dm_open_count(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return atomic_read(&md->open_count);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Guarantees nothing is using the device before it's deleted.
|
|
|
|
*/
|
|
|
|
int dm_lock_for_deletion(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
spin_lock(&_minor_lock);
|
|
|
|
|
|
|
|
if (dm_open_count(md))
|
|
|
|
r = -EBUSY;
|
|
|
|
else
|
|
|
|
set_bit(DMF_DELETING, &md->flags);
|
|
|
|
|
|
|
|
spin_unlock(&_minor_lock);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2006-03-27 09:17:54 +00:00
|
|
|
static int dm_blk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = bdev->bd_disk->private_data;
|
|
|
|
|
|
|
|
return dm_get_geometry(md, geo);
|
|
|
|
}
|
|
|
|
|
2008-03-02 15:29:31 +00:00
|
|
|
static int dm_blk_ioctl(struct block_device *bdev, fmode_t mode,
|
2006-10-03 08:15:15 +00:00
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
2008-03-02 15:29:31 +00:00
|
|
|
struct mapped_device *md = bdev->bd_disk->private_data;
|
|
|
|
struct dm_table *map = dm_get_table(md);
|
2006-10-03 08:15:15 +00:00
|
|
|
struct dm_target *tgt;
|
|
|
|
int r = -ENOTTY;
|
|
|
|
|
|
|
|
if (!map || !dm_table_get_size(map))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* We only support devices that have a single target */
|
|
|
|
if (dm_table_get_num_targets(map) != 1)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
tgt = dm_table_get_target(map, 0);
|
|
|
|
|
|
|
|
if (dm_suspended(md)) {
|
|
|
|
r = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tgt->type->ioctl)
|
2007-08-29 02:15:59 +00:00
|
|
|
r = tgt->type->ioctl(tgt, cmd, arg);
|
2006-10-03 08:15:15 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
dm_table_put(map);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-07-12 16:26:32 +00:00
|
|
|
static struct dm_io *alloc_io(struct mapped_device *md)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return mempool_alloc(md->io_pool, GFP_NOIO);
|
|
|
|
}
|
|
|
|
|
2007-07-12 16:26:32 +00:00
|
|
|
static void free_io(struct mapped_device *md, struct dm_io *io)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
mempool_free(io, md->io_pool);
|
|
|
|
}
|
|
|
|
|
2007-07-12 16:26:32 +00:00
|
|
|
static void free_tio(struct mapped_device *md, struct dm_target_io *tio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
mempool_free(tio, md->tio_pool);
|
|
|
|
}
|
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
static struct dm_rq_target_io *alloc_rq_tio(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return mempool_alloc(md->tio_pool, GFP_ATOMIC);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_rq_tio(struct dm_rq_target_io *tio)
|
|
|
|
{
|
|
|
|
mempool_free(tio, tio->md->tio_pool);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dm_rq_clone_bio_info *alloc_bio_info(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return mempool_alloc(md->io_pool, GFP_ATOMIC);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_bio_info(struct dm_rq_clone_bio_info *info)
|
|
|
|
{
|
|
|
|
mempool_free(info, info->tio->md->io_pool);
|
|
|
|
}
|
|
|
|
|
2006-02-01 11:04:53 +00:00
|
|
|
static void start_io_acct(struct dm_io *io)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = io->md;
|
2008-08-25 10:47:21 +00:00
|
|
|
int cpu;
|
2006-02-01 11:04:53 +00:00
|
|
|
|
|
|
|
io->start_time = jiffies;
|
|
|
|
|
2008-08-25 10:56:14 +00:00
|
|
|
cpu = part_stat_lock();
|
|
|
|
part_round_stats(cpu, &dm_disk(md)->part0);
|
|
|
|
part_stat_unlock();
|
Revert "Seperate read and write statistics of in_flight requests"
This reverts commit a9327cac440be4d8333bba975cbbf76045096275.
Corrado Zoccolo <czoccolo@gmail.com> reports:
"with 2.6.32-rc1 I started getting the following strange output from
"iostat -kx 2":
Linux 2.6.31bisect (et2) 04/10/2009 _i686_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
10,70 0,00 3,16 15,75 0,00 70,38
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 18,22 0,00 0,67 0,01 14,77 0,02
43,94 0,01 10,53 39043915,03 2629219,87
sdb 60,89 9,68 50,79 3,04 1724,43 50,52
65,95 0,70 13,06 488437,47 2629219,87
avg-cpu: %user %nice %system %iowait %steal %idle
2,72 0,00 0,74 0,00 0,00 96,53
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
6,68 0,00 0,99 0,00 0,00 92,33
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
4,40 0,00 0,73 1,47 0,00 93,40
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 4,00 0,00 3,00 0,00 28,00
18,67 0,06 19,50 333,33 100,00
Global values for service time and utilization are garbage. For
interval values, utilization is always 100%, and service time is
higher than normal.
I bisected it down to:
[a9327cac440be4d8333bba975cbbf76045096275] Seperate read and write
statistics of in_flight requests
and verified that reverting just that commit indeed solves the issue
on 2.6.32-rc1."
So until this is debugged, revert the bad commit.
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2009-10-04 19:04:38 +00:00
|
|
|
dm_disk(md)->part0.in_flight = atomic_inc_return(&md->pending);
|
2006-02-01 11:04:53 +00:00
|
|
|
}
|
|
|
|
|
2008-11-13 23:39:10 +00:00
|
|
|
static void end_io_acct(struct dm_io *io)
|
2006-02-01 11:04:53 +00:00
|
|
|
{
|
|
|
|
struct mapped_device *md = io->md;
|
|
|
|
struct bio *bio = io->bio;
|
|
|
|
unsigned long duration = jiffies - io->start_time;
|
2008-08-25 10:47:21 +00:00
|
|
|
int pending, cpu;
|
2006-02-01 11:04:53 +00:00
|
|
|
int rw = bio_data_dir(bio);
|
|
|
|
|
2008-08-25 10:56:14 +00:00
|
|
|
cpu = part_stat_lock();
|
|
|
|
part_round_stats(cpu, &dm_disk(md)->part0);
|
|
|
|
part_stat_add(cpu, &dm_disk(md)->part0, ticks[rw], duration);
|
|
|
|
part_stat_unlock();
|
2006-02-01 11:04:53 +00:00
|
|
|
|
2009-04-08 23:27:16 +00:00
|
|
|
/*
|
|
|
|
* After this is decremented the bio must not be touched if it is
|
|
|
|
* a barrier.
|
|
|
|
*/
|
Revert "Seperate read and write statistics of in_flight requests"
This reverts commit a9327cac440be4d8333bba975cbbf76045096275.
Corrado Zoccolo <czoccolo@gmail.com> reports:
"with 2.6.32-rc1 I started getting the following strange output from
"iostat -kx 2":
Linux 2.6.31bisect (et2) 04/10/2009 _i686_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
10,70 0,00 3,16 15,75 0,00 70,38
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 18,22 0,00 0,67 0,01 14,77 0,02
43,94 0,01 10,53 39043915,03 2629219,87
sdb 60,89 9,68 50,79 3,04 1724,43 50,52
65,95 0,70 13,06 488437,47 2629219,87
avg-cpu: %user %nice %system %iowait %steal %idle
2,72 0,00 0,74 0,00 0,00 96,53
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
6,68 0,00 0,99 0,00 0,00 92,33
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
4,40 0,00 0,73 1,47 0,00 93,40
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 4,00 0,00 3,00 0,00 28,00
18,67 0,06 19,50 333,33 100,00
Global values for service time and utilization are garbage. For
interval values, utilization is always 100%, and service time is
higher than normal.
I bisected it down to:
[a9327cac440be4d8333bba975cbbf76045096275] Seperate read and write
statistics of in_flight requests
and verified that reverting just that commit indeed solves the issue
on 2.6.32-rc1."
So until this is debugged, revert the bad commit.
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2009-10-04 19:04:38 +00:00
|
|
|
dm_disk(md)->part0.in_flight = pending =
|
|
|
|
atomic_dec_return(&md->pending);
|
2006-02-01 11:04:53 +00:00
|
|
|
|
2008-11-13 23:39:10 +00:00
|
|
|
/* nudge anyone waiting on suspend queue */
|
|
|
|
if (!pending)
|
|
|
|
wake_up(&md->wait);
|
2006-02-01 11:04:53 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Add the bio to the list of deferred io.
|
|
|
|
*/
|
2009-04-08 23:27:15 +00:00
|
|
|
static void queue_io(struct mapped_device *md, struct bio *bio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-07-29 04:16:00 +00:00
|
|
|
down_write(&md->io_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-02 18:55:39 +00:00
|
|
|
spin_lock_irq(&md->deferred_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
bio_list_add(&md->deferred, bio);
|
2009-04-02 18:55:39 +00:00
|
|
|
spin_unlock_irq(&md->deferred_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:15 +00:00
|
|
|
if (!test_and_set_bit(DMF_QUEUE_IO_TO_THREAD, &md->flags))
|
|
|
|
queue_work(md->wq, &md->work);
|
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
up_write(&md->io_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Everyone (including functions in this file), should use this
|
|
|
|
* function to access the md->map field, and make sure they call
|
|
|
|
* dm_table_put() when finished.
|
|
|
|
*/
|
|
|
|
struct dm_table *dm_get_table(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
struct dm_table *t;
|
2009-06-22 09:12:37 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-22 09:12:37 +00:00
|
|
|
read_lock_irqsave(&md->map_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
t = md->map;
|
|
|
|
if (t)
|
|
|
|
dm_table_get(t);
|
2009-06-22 09:12:37 +00:00
|
|
|
read_unlock_irqrestore(&md->map_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
2006-03-27 09:17:54 +00:00
|
|
|
/*
|
|
|
|
* Get the geometry associated with a dm device
|
|
|
|
*/
|
|
|
|
int dm_get_geometry(struct mapped_device *md, struct hd_geometry *geo)
|
|
|
|
{
|
|
|
|
*geo = md->geometry;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the geometry of a device.
|
|
|
|
*/
|
|
|
|
int dm_set_geometry(struct mapped_device *md, struct hd_geometry *geo)
|
|
|
|
{
|
|
|
|
sector_t sz = (sector_t)geo->cylinders * geo->heads * geo->sectors;
|
|
|
|
|
|
|
|
if (geo->start > sz) {
|
|
|
|
DMWARN("Start sector is beyond the geometry limits.");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
md->geometry = *geo;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* CRUD START:
|
|
|
|
* A more elegant soln is in the works that uses the queue
|
|
|
|
* merge fn, unfortunately there are a couple of changes to
|
|
|
|
* the block layer that I want to make for this. So in the
|
|
|
|
* interests of getting something for people to use I give
|
|
|
|
* you this clearly demarcated crap.
|
|
|
|
*---------------------------------------------------------------*/
|
|
|
|
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
static int __noflush_suspending(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return test_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Decrements the number of outstanding ios that a bio has been
|
|
|
|
* cloned into, completing the original io if necc.
|
|
|
|
*/
|
2006-01-14 21:20:43 +00:00
|
|
|
static void dec_pending(struct dm_io *io, int error)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
unsigned long flags;
|
2009-03-16 17:44:36 +00:00
|
|
|
int io_error;
|
|
|
|
struct bio *bio;
|
|
|
|
struct mapped_device *md = io->md;
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
|
|
|
|
/* Push-back supersedes any I/O errors */
|
2009-03-16 17:44:36 +00:00
|
|
|
if (error && !(io->error > 0 && __noflush_suspending(md)))
|
2005-04-16 22:20:36 +00:00
|
|
|
io->error = error;
|
|
|
|
|
|
|
|
if (atomic_dec_and_test(&io->io_count)) {
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
if (io->error == DM_ENDIO_REQUEUE) {
|
|
|
|
/*
|
|
|
|
* Target requested pushing back the I/O.
|
|
|
|
*/
|
2009-04-02 18:55:39 +00:00
|
|
|
spin_lock_irqsave(&md->deferred_lock, flags);
|
2009-06-22 09:12:18 +00:00
|
|
|
if (__noflush_suspending(md)) {
|
2009-09-11 12:32:04 +00:00
|
|
|
if (!bio_rw_flagged(io->bio, BIO_RW_BARRIER))
|
2009-06-22 09:12:18 +00:00
|
|
|
bio_list_add_head(&md->deferred,
|
|
|
|
io->bio);
|
|
|
|
} else
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
/* noflush suspend was interrupted. */
|
|
|
|
io->error = -EIO;
|
2009-04-02 18:55:39 +00:00
|
|
|
spin_unlock_irqrestore(&md->deferred_lock, flags);
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
}
|
|
|
|
|
2009-03-16 17:44:36 +00:00
|
|
|
io_error = io->error;
|
|
|
|
bio = io->bio;
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
|
2009-09-11 12:32:04 +00:00
|
|
|
if (bio_rw_flagged(bio, BIO_RW_BARRIER)) {
|
2009-04-08 23:27:16 +00:00
|
|
|
/*
|
|
|
|
* There can be just one barrier request so we use
|
|
|
|
* a per-device variable for error reporting.
|
|
|
|
* Note that you can't touch the bio after end_io_acct
|
|
|
|
*/
|
2009-06-22 09:12:19 +00:00
|
|
|
if (!md->barrier_error && io_error != -EOPNOTSUPP)
|
2009-06-22 09:12:18 +00:00
|
|
|
md->barrier_error = io_error;
|
2009-04-08 23:27:16 +00:00
|
|
|
end_io_acct(io);
|
|
|
|
} else {
|
|
|
|
end_io_acct(io);
|
2009-03-16 17:44:36 +00:00
|
|
|
|
2009-04-08 23:27:16 +00:00
|
|
|
if (io_error != DM_ENDIO_REQUEUE) {
|
|
|
|
trace_block_bio_complete(md->queue, bio);
|
2006-03-23 19:00:26 +00:00
|
|
|
|
2009-04-08 23:27:16 +00:00
|
|
|
bio_endio(bio, io_error);
|
|
|
|
}
|
2009-03-16 17:44:36 +00:00
|
|
|
}
|
2009-04-08 23:27:16 +00:00
|
|
|
|
|
|
|
free_io(md, io);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-27 10:47:43 +00:00
|
|
|
static void clone_endio(struct bio *bio, int error)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int r = 0;
|
2007-07-12 16:26:32 +00:00
|
|
|
struct dm_target_io *tio = bio->bi_private;
|
2009-03-16 17:44:36 +00:00
|
|
|
struct dm_io *io = tio->io;
|
2006-10-03 08:15:41 +00:00
|
|
|
struct mapped_device *md = tio->io->md;
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_endio_fn endio = tio->ti->type->end_io;
|
|
|
|
|
|
|
|
if (!bio_flagged(bio, BIO_UPTODATE) && !error)
|
|
|
|
error = -EIO;
|
|
|
|
|
|
|
|
if (endio) {
|
|
|
|
r = endio(tio->ti, bio, error, &tio->info);
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
if (r < 0 || r == DM_ENDIO_REQUEUE)
|
|
|
|
/*
|
|
|
|
* error and requeue request are handled
|
|
|
|
* in dec_pending().
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
error = r;
|
2006-12-08 10:41:05 +00:00
|
|
|
else if (r == DM_ENDIO_INCOMPLETE)
|
|
|
|
/* The target will handle the io */
|
2007-09-27 10:47:43 +00:00
|
|
|
return;
|
2006-12-08 10:41:05 +00:00
|
|
|
else if (r) {
|
|
|
|
DMWARN("unimplemented target endio return value: %d", r);
|
|
|
|
BUG();
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-10-03 08:15:41 +00:00
|
|
|
/*
|
|
|
|
* Store md for cleanup instead of tio which is about to get freed.
|
|
|
|
*/
|
|
|
|
bio->bi_private = md->bs;
|
|
|
|
|
|
|
|
free_tio(md, tio);
|
2009-03-16 17:44:36 +00:00
|
|
|
bio_put(bio);
|
|
|
|
dec_pending(io, error);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
/*
|
|
|
|
* Partial completion handling for request-based dm
|
|
|
|
*/
|
|
|
|
static void end_clone_bio(struct bio *clone, int error)
|
|
|
|
{
|
|
|
|
struct dm_rq_clone_bio_info *info = clone->bi_private;
|
|
|
|
struct dm_rq_target_io *tio = info->tio;
|
|
|
|
struct bio *bio = info->orig;
|
|
|
|
unsigned int nr_bytes = info->orig->bi_size;
|
|
|
|
|
|
|
|
bio_put(clone);
|
|
|
|
|
|
|
|
if (tio->error)
|
|
|
|
/*
|
|
|
|
* An error has already been detected on the request.
|
|
|
|
* Once error occurred, just let clone->end_io() handle
|
|
|
|
* the remainder.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
else if (error) {
|
|
|
|
/*
|
|
|
|
* Don't notice the error to the upper layer yet.
|
|
|
|
* The error handling decision is made by the target driver,
|
|
|
|
* when the request is completed.
|
|
|
|
*/
|
|
|
|
tio->error = error;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* I/O for the bio successfully completed.
|
|
|
|
* Notice the data completion to the upper layer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bios are processed from the head of the list.
|
|
|
|
* So the completing bio should always be rq->bio.
|
|
|
|
* If it's not, something wrong is happening.
|
|
|
|
*/
|
|
|
|
if (tio->orig->bio != bio)
|
|
|
|
DMERR("bio completion is going in the middle of the request");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update the original request.
|
|
|
|
* Do not use blk_end_request() here, because it may complete
|
|
|
|
* the original request before the clone, and break the ordering.
|
|
|
|
*/
|
|
|
|
blk_update_request(tio->orig, 0, nr_bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't touch any member of the md after calling this function because
|
|
|
|
* the md may be freed in dm_put() at the end of this function.
|
|
|
|
* Or do dm_get() before calling this function and dm_put() later.
|
|
|
|
*/
|
|
|
|
static void rq_completed(struct mapped_device *md, int run_queue)
|
|
|
|
{
|
|
|
|
int wakeup_waiters = 0;
|
|
|
|
struct request_queue *q = md->queue;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
if (!queue_in_flight(q))
|
|
|
|
wakeup_waiters = 1;
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
|
|
|
|
/* nudge anyone waiting on suspend queue */
|
|
|
|
if (wakeup_waiters)
|
|
|
|
wake_up(&md->wait);
|
|
|
|
|
|
|
|
if (run_queue)
|
|
|
|
blk_run_queue(q);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dm_put() must be at the end of this function. See the comment above
|
|
|
|
*/
|
|
|
|
dm_put(md);
|
|
|
|
}
|
|
|
|
|
2009-09-04 19:40:16 +00:00
|
|
|
static void free_rq_clone(struct request *clone)
|
|
|
|
{
|
|
|
|
struct dm_rq_target_io *tio = clone->end_io_data;
|
|
|
|
|
|
|
|
blk_rq_unprep_clone(clone);
|
|
|
|
free_rq_tio(tio);
|
|
|
|
}
|
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
static void dm_unprep_request(struct request *rq)
|
|
|
|
{
|
|
|
|
struct request *clone = rq->special;
|
|
|
|
|
|
|
|
rq->special = NULL;
|
|
|
|
rq->cmd_flags &= ~REQ_DONTPREP;
|
|
|
|
|
2009-09-04 19:40:16 +00:00
|
|
|
free_rq_clone(clone);
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Requeue the original request of a clone.
|
|
|
|
*/
|
|
|
|
void dm_requeue_unmapped_request(struct request *clone)
|
|
|
|
{
|
|
|
|
struct dm_rq_target_io *tio = clone->end_io_data;
|
|
|
|
struct mapped_device *md = tio->md;
|
|
|
|
struct request *rq = tio->orig;
|
|
|
|
struct request_queue *q = rq->q;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
dm_unprep_request(rq);
|
|
|
|
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
if (elv_queue_empty(q))
|
|
|
|
blk_plug_device(q);
|
|
|
|
blk_requeue_request(q, rq);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
|
|
|
|
rq_completed(md, 0);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dm_requeue_unmapped_request);
|
|
|
|
|
|
|
|
static void __stop_queue(struct request_queue *q)
|
|
|
|
{
|
|
|
|
blk_stop_queue(q);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void stop_queue(struct request_queue *q)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
__stop_queue(q);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __start_queue(struct request_queue *q)
|
|
|
|
{
|
|
|
|
if (blk_queue_stopped(q))
|
|
|
|
blk_start_queue(q);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void start_queue(struct request_queue *q)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
__start_queue(q);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Complete the clone and the original request.
|
|
|
|
* Must be called without queue lock.
|
|
|
|
*/
|
|
|
|
static void dm_end_request(struct request *clone, int error)
|
|
|
|
{
|
|
|
|
struct dm_rq_target_io *tio = clone->end_io_data;
|
|
|
|
struct mapped_device *md = tio->md;
|
|
|
|
struct request *rq = tio->orig;
|
|
|
|
|
|
|
|
if (blk_pc_request(rq)) {
|
|
|
|
rq->errors = clone->errors;
|
|
|
|
rq->resid_len = clone->resid_len;
|
|
|
|
|
|
|
|
if (rq->sense)
|
|
|
|
/*
|
|
|
|
* We are using the sense buffer of the original
|
|
|
|
* request.
|
|
|
|
* So setting the length of the sense data is enough.
|
|
|
|
*/
|
|
|
|
rq->sense_len = clone->sense_len;
|
|
|
|
}
|
|
|
|
|
2009-09-04 19:40:16 +00:00
|
|
|
free_rq_clone(clone);
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
|
|
|
|
blk_end_request_all(rq, error);
|
|
|
|
|
|
|
|
rq_completed(md, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Request completion handler for request-based dm
|
|
|
|
*/
|
|
|
|
static void dm_softirq_done(struct request *rq)
|
|
|
|
{
|
|
|
|
struct request *clone = rq->completion_data;
|
|
|
|
struct dm_rq_target_io *tio = clone->end_io_data;
|
|
|
|
dm_request_endio_fn rq_end_io = tio->ti->type->rq_end_io;
|
|
|
|
int error = tio->error;
|
|
|
|
|
|
|
|
if (!(rq->cmd_flags & REQ_FAILED) && rq_end_io)
|
|
|
|
error = rq_end_io(tio->ti, clone, error, &tio->info);
|
|
|
|
|
|
|
|
if (error <= 0)
|
|
|
|
/* The target wants to complete the I/O */
|
|
|
|
dm_end_request(clone, error);
|
|
|
|
else if (error == DM_ENDIO_INCOMPLETE)
|
|
|
|
/* The target will handle the I/O */
|
|
|
|
return;
|
|
|
|
else if (error == DM_ENDIO_REQUEUE)
|
|
|
|
/* The target wants to requeue the I/O */
|
|
|
|
dm_requeue_unmapped_request(clone);
|
|
|
|
else {
|
|
|
|
DMWARN("unimplemented target endio return value: %d", error);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Complete the clone and the original request with the error status
|
|
|
|
* through softirq context.
|
|
|
|
*/
|
|
|
|
static void dm_complete_request(struct request *clone, int error)
|
|
|
|
{
|
|
|
|
struct dm_rq_target_io *tio = clone->end_io_data;
|
|
|
|
struct request *rq = tio->orig;
|
|
|
|
|
|
|
|
tio->error = error;
|
|
|
|
rq->completion_data = clone;
|
|
|
|
blk_complete_request(rq);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Complete the not-mapped clone and the original request with the error status
|
|
|
|
* through softirq context.
|
|
|
|
* Target's rq_end_io() function isn't called.
|
|
|
|
* This may be used when the target's map_rq() function fails.
|
|
|
|
*/
|
|
|
|
void dm_kill_unmapped_request(struct request *clone, int error)
|
|
|
|
{
|
|
|
|
struct dm_rq_target_io *tio = clone->end_io_data;
|
|
|
|
struct request *rq = tio->orig;
|
|
|
|
|
|
|
|
rq->cmd_flags |= REQ_FAILED;
|
|
|
|
dm_complete_request(clone, error);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dm_kill_unmapped_request);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called with the queue lock held
|
|
|
|
*/
|
|
|
|
static void end_clone_request(struct request *clone, int error)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* For just cleaning up the information of the queue in which
|
|
|
|
* the clone was dispatched.
|
|
|
|
* The clone is *NOT* freed actually here because it is alloced from
|
|
|
|
* dm own mempool and REQ_ALLOCED isn't set in clone->cmd_flags.
|
|
|
|
*/
|
|
|
|
__blk_put_request(clone->q, clone);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Actual request completion is done in a softirq context which doesn't
|
|
|
|
* hold the queue lock. Otherwise, deadlock could occur because:
|
|
|
|
* - another request may be submitted by the upper level driver
|
|
|
|
* of the stacking during the completion
|
|
|
|
* - the submission which requires queue lock may be done
|
|
|
|
* against this queue
|
|
|
|
*/
|
|
|
|
dm_complete_request(clone, error);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static sector_t max_io_len(struct mapped_device *md,
|
|
|
|
sector_t sector, struct dm_target *ti)
|
|
|
|
{
|
|
|
|
sector_t offset = sector - ti->begin;
|
|
|
|
sector_t len = ti->len - offset;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Does the target need to split even further ?
|
|
|
|
*/
|
|
|
|
if (ti->split_io) {
|
|
|
|
sector_t boundary;
|
|
|
|
boundary = ((offset + ti->split_io) & ~(ti->split_io - 1))
|
|
|
|
- offset;
|
|
|
|
if (len > boundary)
|
|
|
|
len = boundary;
|
|
|
|
}
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __map_bio(struct dm_target *ti, struct bio *clone,
|
2007-07-12 16:26:32 +00:00
|
|
|
struct dm_target_io *tio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int r;
|
2006-03-23 19:00:26 +00:00
|
|
|
sector_t sector;
|
2006-10-03 08:15:41 +00:00
|
|
|
struct mapped_device *md;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
clone->bi_end_io = clone_endio;
|
|
|
|
clone->bi_private = tio;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Map the clone. If r == 0 we don't need to do
|
|
|
|
* anything, the target has assumed ownership of
|
|
|
|
* this io.
|
|
|
|
*/
|
|
|
|
atomic_inc(&tio->io->io_count);
|
2006-03-23 19:00:26 +00:00
|
|
|
sector = clone->bi_sector;
|
2005-04-16 22:20:36 +00:00
|
|
|
r = ti->type->map(ti, clone, &tio->info);
|
2006-12-08 10:41:05 +00:00
|
|
|
if (r == DM_MAPIO_REMAPPED) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* the bio has been remapped so dispatch it */
|
2006-03-23 19:00:26 +00:00
|
|
|
|
2008-10-30 07:34:33 +00:00
|
|
|
trace_block_remap(bdev_get_queue(clone->bi_bdev), clone,
|
2009-05-04 20:35:08 +00:00
|
|
|
tio->io->bio->bi_bdev->bd_dev, sector);
|
2006-03-23 19:00:26 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
generic_make_request(clone);
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
} else if (r < 0 || r == DM_MAPIO_REQUEUE) {
|
|
|
|
/* error the io and bail out, or requeue it if needed */
|
2006-10-03 08:15:41 +00:00
|
|
|
md = tio->io->md;
|
|
|
|
dec_pending(tio->io, r);
|
|
|
|
/*
|
|
|
|
* Store bio_set for cleanup.
|
|
|
|
*/
|
|
|
|
clone->bi_private = md->bs;
|
2005-04-16 22:20:36 +00:00
|
|
|
bio_put(clone);
|
2006-10-03 08:15:41 +00:00
|
|
|
free_tio(md, tio);
|
2006-12-08 10:41:05 +00:00
|
|
|
} else if (r) {
|
|
|
|
DMWARN("unimplemented target map return value: %d", r);
|
|
|
|
BUG();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct clone_info {
|
|
|
|
struct mapped_device *md;
|
|
|
|
struct dm_table *map;
|
|
|
|
struct bio *bio;
|
|
|
|
struct dm_io *io;
|
|
|
|
sector_t sector;
|
|
|
|
sector_t sector_count;
|
|
|
|
unsigned short idx;
|
|
|
|
};
|
|
|
|
|
2005-09-06 22:16:42 +00:00
|
|
|
static void dm_bio_destructor(struct bio *bio)
|
|
|
|
{
|
2006-10-03 08:15:41 +00:00
|
|
|
struct bio_set *bs = bio->bi_private;
|
|
|
|
|
|
|
|
bio_free(bio, bs);
|
2005-09-06 22:16:42 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Creates a little bio that is just does part of a bvec.
|
|
|
|
*/
|
|
|
|
static struct bio *split_bvec(struct bio *bio, sector_t sector,
|
|
|
|
unsigned short idx, unsigned int offset,
|
2006-10-03 08:15:41 +00:00
|
|
|
unsigned int len, struct bio_set *bs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct bio *clone;
|
|
|
|
struct bio_vec *bv = bio->bi_io_vec + idx;
|
|
|
|
|
2006-10-03 08:15:41 +00:00
|
|
|
clone = bio_alloc_bioset(GFP_NOIO, 1, bs);
|
2005-09-06 22:16:42 +00:00
|
|
|
clone->bi_destructor = dm_bio_destructor;
|
2005-04-16 22:20:36 +00:00
|
|
|
*clone->bi_io_vec = *bv;
|
|
|
|
|
|
|
|
clone->bi_sector = sector;
|
|
|
|
clone->bi_bdev = bio->bi_bdev;
|
2009-04-08 23:27:16 +00:00
|
|
|
clone->bi_rw = bio->bi_rw & ~(1 << BIO_RW_BARRIER);
|
2005-04-16 22:20:36 +00:00
|
|
|
clone->bi_vcnt = 1;
|
|
|
|
clone->bi_size = to_bytes(len);
|
|
|
|
clone->bi_io_vec->bv_offset = offset;
|
|
|
|
clone->bi_io_vec->bv_len = clone->bi_size;
|
2008-10-21 16:45:04 +00:00
|
|
|
clone->bi_flags |= 1 << BIO_CLONED;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:12 +00:00
|
|
|
if (bio_integrity(bio)) {
|
2009-06-26 13:37:49 +00:00
|
|
|
bio_integrity_clone(clone, bio, GFP_NOIO, bs);
|
2009-04-08 23:27:12 +00:00
|
|
|
bio_integrity_trim(clone,
|
|
|
|
bio_sector_offset(bio, idx, offset), len);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return clone;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Creates a bio that consists of range of complete bvecs.
|
|
|
|
*/
|
|
|
|
static struct bio *clone_bio(struct bio *bio, sector_t sector,
|
|
|
|
unsigned short idx, unsigned short bv_count,
|
2006-10-03 08:15:41 +00:00
|
|
|
unsigned int len, struct bio_set *bs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct bio *clone;
|
|
|
|
|
2006-10-03 08:15:41 +00:00
|
|
|
clone = bio_alloc_bioset(GFP_NOIO, bio->bi_max_vecs, bs);
|
|
|
|
__bio_clone(clone, bio);
|
2009-04-08 23:27:16 +00:00
|
|
|
clone->bi_rw &= ~(1 << BIO_RW_BARRIER);
|
2006-10-03 08:15:41 +00:00
|
|
|
clone->bi_destructor = dm_bio_destructor;
|
2005-04-16 22:20:36 +00:00
|
|
|
clone->bi_sector = sector;
|
|
|
|
clone->bi_idx = idx;
|
|
|
|
clone->bi_vcnt = idx + bv_count;
|
|
|
|
clone->bi_size = to_bytes(len);
|
|
|
|
clone->bi_flags &= ~(1 << BIO_SEG_VALID);
|
|
|
|
|
2009-04-08 23:27:12 +00:00
|
|
|
if (bio_integrity(bio)) {
|
2009-06-26 13:37:49 +00:00
|
|
|
bio_integrity_clone(clone, bio, GFP_NOIO, bs);
|
2009-04-08 23:27:12 +00:00
|
|
|
|
|
|
|
if (idx != bio->bi_idx || clone->bi_size < bio->bi_size)
|
|
|
|
bio_integrity_trim(clone,
|
|
|
|
bio_sector_offset(bio, idx, 0), len);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return clone;
|
|
|
|
}
|
|
|
|
|
2009-06-22 09:12:21 +00:00
|
|
|
static struct dm_target_io *alloc_tio(struct clone_info *ci,
|
|
|
|
struct dm_target *ti)
|
2009-06-22 09:12:20 +00:00
|
|
|
{
|
2009-06-22 09:12:21 +00:00
|
|
|
struct dm_target_io *tio = mempool_alloc(ci->md->tio_pool, GFP_NOIO);
|
2009-06-22 09:12:20 +00:00
|
|
|
|
|
|
|
tio->io = ci->io;
|
|
|
|
tio->ti = ti;
|
|
|
|
memset(&tio->info, 0, sizeof(tio->info));
|
2009-06-22 09:12:21 +00:00
|
|
|
|
|
|
|
return tio;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __flush_target(struct clone_info *ci, struct dm_target *ti,
|
|
|
|
unsigned flush_nr)
|
|
|
|
{
|
|
|
|
struct dm_target_io *tio = alloc_tio(ci, ti);
|
|
|
|
struct bio *clone;
|
|
|
|
|
2009-06-22 09:12:20 +00:00
|
|
|
tio->info.flush_request = flush_nr;
|
|
|
|
|
|
|
|
clone = bio_alloc_bioset(GFP_NOIO, 0, ci->md->bs);
|
|
|
|
__bio_clone(clone, ci->bio);
|
|
|
|
clone->bi_destructor = dm_bio_destructor;
|
|
|
|
|
|
|
|
__map_bio(ti, clone, tio);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __clone_and_map_empty_barrier(struct clone_info *ci)
|
|
|
|
{
|
|
|
|
unsigned target_nr = 0, flush_nr;
|
|
|
|
struct dm_target *ti;
|
|
|
|
|
|
|
|
while ((ti = dm_table_get_target(ci->map, target_nr++)))
|
|
|
|
for (flush_nr = 0; flush_nr < ti->num_flush_requests;
|
|
|
|
flush_nr++)
|
|
|
|
__flush_target(ci, ti, flush_nr);
|
|
|
|
|
|
|
|
ci->sector_count = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-13 14:15:25 +00:00
|
|
|
static int __clone_and_map(struct clone_info *ci)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct bio *clone, *bio = ci->bio;
|
2007-12-13 14:15:25 +00:00
|
|
|
struct dm_target *ti;
|
|
|
|
sector_t len = 0, max;
|
2007-07-12 16:26:32 +00:00
|
|
|
struct dm_target_io *tio;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-22 09:12:20 +00:00
|
|
|
if (unlikely(bio_empty_barrier(bio)))
|
|
|
|
return __clone_and_map_empty_barrier(ci);
|
|
|
|
|
2007-12-13 14:15:25 +00:00
|
|
|
ti = dm_table_find_target(ci->map, ci->sector);
|
|
|
|
if (!dm_target_is_valid(ti))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
max = max_io_len(ci->md, ci->sector, ti);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Allocate a target io object.
|
|
|
|
*/
|
2009-06-22 09:12:21 +00:00
|
|
|
tio = alloc_tio(ci, ti);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (ci->sector_count <= max) {
|
|
|
|
/*
|
|
|
|
* Optimise for the simple case where we can do all of
|
|
|
|
* the remaining io with a single clone.
|
|
|
|
*/
|
|
|
|
clone = clone_bio(bio, ci->sector, ci->idx,
|
2006-10-03 08:15:41 +00:00
|
|
|
bio->bi_vcnt - ci->idx, ci->sector_count,
|
|
|
|
ci->md->bs);
|
2005-04-16 22:20:36 +00:00
|
|
|
__map_bio(ti, clone, tio);
|
|
|
|
ci->sector_count = 0;
|
|
|
|
|
|
|
|
} else if (to_sector(bio->bi_io_vec[ci->idx].bv_len) <= max) {
|
|
|
|
/*
|
|
|
|
* There are some bvecs that don't span targets.
|
|
|
|
* Do as many of these as possible.
|
|
|
|
*/
|
|
|
|
int i;
|
|
|
|
sector_t remaining = max;
|
|
|
|
sector_t bv_len;
|
|
|
|
|
|
|
|
for (i = ci->idx; remaining && (i < bio->bi_vcnt); i++) {
|
|
|
|
bv_len = to_sector(bio->bi_io_vec[i].bv_len);
|
|
|
|
|
|
|
|
if (bv_len > remaining)
|
|
|
|
break;
|
|
|
|
|
|
|
|
remaining -= bv_len;
|
|
|
|
len += bv_len;
|
|
|
|
}
|
|
|
|
|
2006-10-03 08:15:41 +00:00
|
|
|
clone = clone_bio(bio, ci->sector, ci->idx, i - ci->idx, len,
|
|
|
|
ci->md->bs);
|
2005-04-16 22:20:36 +00:00
|
|
|
__map_bio(ti, clone, tio);
|
|
|
|
|
|
|
|
ci->sector += len;
|
|
|
|
ci->sector_count -= len;
|
|
|
|
ci->idx = i;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/*
|
2006-03-22 08:07:42 +00:00
|
|
|
* Handle a bvec that must be split between two or more targets.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
struct bio_vec *bv = bio->bi_io_vec + ci->idx;
|
2006-03-22 08:07:42 +00:00
|
|
|
sector_t remaining = to_sector(bv->bv_len);
|
|
|
|
unsigned int offset = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-03-22 08:07:42 +00:00
|
|
|
do {
|
|
|
|
if (offset) {
|
|
|
|
ti = dm_table_find_target(ci->map, ci->sector);
|
2007-12-13 14:15:25 +00:00
|
|
|
if (!dm_target_is_valid(ti))
|
|
|
|
return -EIO;
|
|
|
|
|
2006-03-22 08:07:42 +00:00
|
|
|
max = max_io_len(ci->md, ci->sector, ti);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-22 09:12:21 +00:00
|
|
|
tio = alloc_tio(ci, ti);
|
2006-03-22 08:07:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
len = min(remaining, max);
|
|
|
|
|
|
|
|
clone = split_bvec(bio, ci->sector, ci->idx,
|
2006-10-03 08:15:41 +00:00
|
|
|
bv->bv_offset + offset, len,
|
|
|
|
ci->md->bs);
|
2006-03-22 08:07:42 +00:00
|
|
|
|
|
|
|
__map_bio(ti, clone, tio);
|
|
|
|
|
|
|
|
ci->sector += len;
|
|
|
|
ci->sector_count -= len;
|
|
|
|
offset += to_bytes(len);
|
|
|
|
} while (remaining -= len);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ci->idx++;
|
|
|
|
}
|
2007-12-13 14:15:25 +00:00
|
|
|
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-04-02 18:55:37 +00:00
|
|
|
* Split the bio into several clones and submit it to targets.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-04-02 18:55:38 +00:00
|
|
|
static void __split_and_process_bio(struct mapped_device *md, struct bio *bio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct clone_info ci;
|
2007-12-13 14:15:25 +00:00
|
|
|
int error = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ci.map = dm_get_table(md);
|
2009-04-02 18:55:38 +00:00
|
|
|
if (unlikely(!ci.map)) {
|
2009-09-11 12:32:04 +00:00
|
|
|
if (!bio_rw_flagged(bio, BIO_RW_BARRIER))
|
2009-04-08 23:27:16 +00:00
|
|
|
bio_io_error(bio);
|
|
|
|
else
|
2009-06-22 09:12:18 +00:00
|
|
|
if (!md->barrier_error)
|
|
|
|
md->barrier_error = -EIO;
|
2009-04-02 18:55:38 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-04-08 23:27:13 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ci.md = md;
|
|
|
|
ci.bio = bio;
|
|
|
|
ci.io = alloc_io(md);
|
|
|
|
ci.io->error = 0;
|
|
|
|
atomic_set(&ci.io->io_count, 1);
|
|
|
|
ci.io->bio = bio;
|
|
|
|
ci.io->md = md;
|
|
|
|
ci.sector = bio->bi_sector;
|
|
|
|
ci.sector_count = bio_sectors(bio);
|
2009-06-22 09:12:20 +00:00
|
|
|
if (unlikely(bio_empty_barrier(bio)))
|
|
|
|
ci.sector_count = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
ci.idx = bio->bi_idx;
|
|
|
|
|
2006-02-01 11:04:53 +00:00
|
|
|
start_io_acct(ci.io);
|
2007-12-13 14:15:25 +00:00
|
|
|
while (ci.sector_count && !error)
|
|
|
|
error = __clone_and_map(&ci);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* drop the extra reference count */
|
2007-12-13 14:15:25 +00:00
|
|
|
dec_pending(ci.io, error);
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_table_put(ci.map);
|
|
|
|
}
|
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* CRUD END
|
|
|
|
*---------------------------------------------------------------*/
|
|
|
|
|
2008-07-21 11:00:37 +00:00
|
|
|
static int dm_merge_bvec(struct request_queue *q,
|
|
|
|
struct bvec_merge_data *bvm,
|
|
|
|
struct bio_vec *biovec)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = q->queuedata;
|
|
|
|
struct dm_table *map = dm_get_table(md);
|
|
|
|
struct dm_target *ti;
|
|
|
|
sector_t max_sectors;
|
2008-10-01 13:39:17 +00:00
|
|
|
int max_size = 0;
|
2008-07-21 11:00:37 +00:00
|
|
|
|
|
|
|
if (unlikely(!map))
|
2008-10-01 13:39:17 +00:00
|
|
|
goto out;
|
2008-07-21 11:00:37 +00:00
|
|
|
|
|
|
|
ti = dm_table_find_target(map, bvm->bi_sector);
|
2008-10-01 13:39:24 +00:00
|
|
|
if (!dm_target_is_valid(ti))
|
|
|
|
goto out_table;
|
2008-07-21 11:00:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find maximum amount of I/O that won't need splitting
|
|
|
|
*/
|
|
|
|
max_sectors = min(max_io_len(md, bvm->bi_sector, ti),
|
|
|
|
(sector_t) BIO_MAX_SECTORS);
|
|
|
|
max_size = (max_sectors << SECTOR_SHIFT) - bvm->bi_size;
|
|
|
|
if (max_size < 0)
|
|
|
|
max_size = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* merge_bvec_fn() returns number of bytes
|
|
|
|
* it can accept at this offset
|
|
|
|
* max is precomputed maximal io size
|
|
|
|
*/
|
|
|
|
if (max_size && ti->type->merge)
|
|
|
|
max_size = ti->type->merge(ti, bvm, biovec, max_size);
|
2009-06-22 09:12:14 +00:00
|
|
|
/*
|
|
|
|
* If the target doesn't support merge method and some of the devices
|
|
|
|
* provided their merge_bvec method (we know this by looking at
|
|
|
|
* queue_max_hw_sectors), then we can't allow bios with multiple vector
|
|
|
|
* entries. So always set max_size to 0, and the code below allows
|
|
|
|
* just one page.
|
|
|
|
*/
|
|
|
|
else if (queue_max_hw_sectors(q) <= PAGE_SIZE >> 9)
|
|
|
|
|
|
|
|
max_size = 0;
|
2008-07-21 11:00:37 +00:00
|
|
|
|
2008-10-01 13:39:24 +00:00
|
|
|
out_table:
|
2008-10-01 13:39:17 +00:00
|
|
|
dm_table_put(map);
|
|
|
|
|
|
|
|
out:
|
2008-07-21 11:00:37 +00:00
|
|
|
/*
|
|
|
|
* Always allow an entire first page
|
|
|
|
*/
|
|
|
|
if (max_size <= biovec->bv_len && !(bvm->bi_size >> SECTOR_SHIFT))
|
|
|
|
max_size = biovec->bv_len;
|
|
|
|
|
|
|
|
return max_size;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The request function that just remaps the bio built up by
|
|
|
|
* dm_merge_bvec.
|
|
|
|
*/
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
static int _dm_request(struct request_queue *q, struct bio *bio)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-02-01 11:04:52 +00:00
|
|
|
int rw = bio_data_dir(bio);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct mapped_device *md = q->queuedata;
|
2008-08-25 10:47:21 +00:00
|
|
|
int cpu;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
down_read(&md->io_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-25 10:56:14 +00:00
|
|
|
cpu = part_stat_lock();
|
|
|
|
part_stat_inc(cpu, &dm_disk(md)->part0, ios[rw]);
|
|
|
|
part_stat_add(cpu, &dm_disk(md)->part0, sectors[rw], bio_sectors(bio));
|
|
|
|
part_stat_unlock();
|
2006-02-01 11:04:52 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2009-04-08 23:27:14 +00:00
|
|
|
* If we're suspended or the thread is processing barriers
|
|
|
|
* we have to queue this io for later.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-04-08 23:27:16 +00:00
|
|
|
if (unlikely(test_bit(DMF_QUEUE_IO_TO_THREAD, &md->flags)) ||
|
2009-09-11 12:32:04 +00:00
|
|
|
unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER))) {
|
2005-07-29 04:16:00 +00:00
|
|
|
up_read(&md->io_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:14 +00:00
|
|
|
if (unlikely(test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) &&
|
|
|
|
bio_rw(bio) == READA) {
|
|
|
|
bio_io_error(bio);
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:15 +00:00
|
|
|
queue_io(md, bio);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:15 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-04-02 18:55:38 +00:00
|
|
|
__split_and_process_bio(md, bio);
|
2005-07-29 04:16:00 +00:00
|
|
|
up_read(&md->io_lock);
|
2009-04-02 18:55:38 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
static int dm_make_request(struct request_queue *q, struct bio *bio)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = q->queuedata;
|
|
|
|
|
2009-09-11 12:32:04 +00:00
|
|
|
if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER))) {
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
bio_endio(bio, -EOPNOTSUPP);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return md->saved_make_request_fn(q, bio); /* call __make_request() */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dm_request_based(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return blk_queue_stackable(md->queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dm_request(struct request_queue *q, struct bio *bio)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = q->queuedata;
|
|
|
|
|
|
|
|
if (dm_request_based(md))
|
|
|
|
return dm_make_request(q, bio);
|
|
|
|
|
|
|
|
return _dm_request(q, bio);
|
|
|
|
}
|
|
|
|
|
|
|
|
void dm_dispatch_request(struct request *rq)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (blk_queue_io_stat(rq->q))
|
|
|
|
rq->cmd_flags |= REQ_IO_STAT;
|
|
|
|
|
|
|
|
rq->start_time = jiffies;
|
|
|
|
r = blk_insert_cloned_request(rq->q, rq);
|
|
|
|
if (r)
|
|
|
|
dm_complete_request(rq, r);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dm_dispatch_request);
|
|
|
|
|
|
|
|
static void dm_rq_bio_destructor(struct bio *bio)
|
|
|
|
{
|
|
|
|
struct dm_rq_clone_bio_info *info = bio->bi_private;
|
|
|
|
struct mapped_device *md = info->tio->md;
|
|
|
|
|
|
|
|
free_bio_info(info);
|
|
|
|
bio_free(bio, md->bs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dm_rq_bio_constructor(struct bio *bio, struct bio *bio_orig,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct dm_rq_target_io *tio = data;
|
|
|
|
struct mapped_device *md = tio->md;
|
|
|
|
struct dm_rq_clone_bio_info *info = alloc_bio_info(md);
|
|
|
|
|
|
|
|
if (!info)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
info->orig = bio_orig;
|
|
|
|
info->tio = tio;
|
|
|
|
bio->bi_end_io = end_clone_bio;
|
|
|
|
bio->bi_private = info;
|
|
|
|
bio->bi_destructor = dm_rq_bio_destructor;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int setup_clone(struct request *clone, struct request *rq,
|
|
|
|
struct dm_rq_target_io *tio)
|
|
|
|
{
|
|
|
|
int r = blk_rq_prep_clone(clone, rq, tio->md->bs, GFP_ATOMIC,
|
|
|
|
dm_rq_bio_constructor, tio);
|
|
|
|
|
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
clone->cmd = rq->cmd;
|
|
|
|
clone->cmd_len = rq->cmd_len;
|
|
|
|
clone->sense = rq->sense;
|
|
|
|
clone->buffer = rq->buffer;
|
|
|
|
clone->end_io = end_clone_request;
|
|
|
|
clone->end_io_data = tio;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dm_rq_flush_suspending(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return !md->suspend_rq.special;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called with the queue lock held.
|
|
|
|
*/
|
|
|
|
static int dm_prep_fn(struct request_queue *q, struct request *rq)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = q->queuedata;
|
|
|
|
struct dm_rq_target_io *tio;
|
|
|
|
struct request *clone;
|
|
|
|
|
|
|
|
if (unlikely(rq == &md->suspend_rq)) {
|
|
|
|
if (dm_rq_flush_suspending(md))
|
|
|
|
return BLKPREP_OK;
|
|
|
|
else
|
|
|
|
/* The flush suspend was interrupted */
|
|
|
|
return BLKPREP_KILL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(rq->special)) {
|
|
|
|
DMWARN("Already has something in rq->special.");
|
|
|
|
return BLKPREP_KILL;
|
|
|
|
}
|
|
|
|
|
|
|
|
tio = alloc_rq_tio(md); /* Only one for each original request */
|
|
|
|
if (!tio)
|
|
|
|
/* -ENOMEM */
|
|
|
|
return BLKPREP_DEFER;
|
|
|
|
|
|
|
|
tio->md = md;
|
|
|
|
tio->ti = NULL;
|
|
|
|
tio->orig = rq;
|
|
|
|
tio->error = 0;
|
|
|
|
memset(&tio->info, 0, sizeof(tio->info));
|
|
|
|
|
|
|
|
clone = &tio->clone;
|
|
|
|
if (setup_clone(clone, rq, tio)) {
|
|
|
|
/* -ENOMEM */
|
|
|
|
free_rq_tio(tio);
|
|
|
|
return BLKPREP_DEFER;
|
|
|
|
}
|
|
|
|
|
|
|
|
rq->special = clone;
|
|
|
|
rq->cmd_flags |= REQ_DONTPREP;
|
|
|
|
|
|
|
|
return BLKPREP_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void map_request(struct dm_target *ti, struct request *rq,
|
|
|
|
struct mapped_device *md)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
struct request *clone = rq->special;
|
|
|
|
struct dm_rq_target_io *tio = clone->end_io_data;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Hold the md reference here for the in-flight I/O.
|
|
|
|
* We can't rely on the reference count by device opener,
|
|
|
|
* because the device may be closed during the request completion
|
|
|
|
* when all bios are completed.
|
|
|
|
* See the comment in rq_completed() too.
|
|
|
|
*/
|
|
|
|
dm_get(md);
|
|
|
|
|
|
|
|
tio->ti = ti;
|
|
|
|
r = ti->type->map_rq(ti, clone, &tio->info);
|
|
|
|
switch (r) {
|
|
|
|
case DM_MAPIO_SUBMITTED:
|
|
|
|
/* The target has taken the I/O to submit by itself later */
|
|
|
|
break;
|
|
|
|
case DM_MAPIO_REMAPPED:
|
|
|
|
/* The target has remapped the I/O so dispatch it */
|
|
|
|
dm_dispatch_request(clone);
|
|
|
|
break;
|
|
|
|
case DM_MAPIO_REQUEUE:
|
|
|
|
/* The target wants to requeue the I/O */
|
|
|
|
dm_requeue_unmapped_request(clone);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (r > 0) {
|
|
|
|
DMWARN("unimplemented target map return value: %d", r);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The target wants to complete the I/O */
|
|
|
|
dm_kill_unmapped_request(clone, r);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* q->request_fn for request-based dm.
|
|
|
|
* Called with the queue lock held.
|
|
|
|
*/
|
|
|
|
static void dm_request_fn(struct request_queue *q)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = q->queuedata;
|
|
|
|
struct dm_table *map = dm_get_table(md);
|
|
|
|
struct dm_target *ti;
|
|
|
|
struct request *rq;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For noflush suspend, check blk_queue_stopped() to immediately
|
|
|
|
* quit I/O dispatching.
|
|
|
|
*/
|
|
|
|
while (!blk_queue_plugged(q) && !blk_queue_stopped(q)) {
|
|
|
|
rq = blk_peek_request(q);
|
|
|
|
if (!rq)
|
|
|
|
goto plug_and_out;
|
|
|
|
|
|
|
|
if (unlikely(rq == &md->suspend_rq)) { /* Flush suspend maker */
|
|
|
|
if (queue_in_flight(q))
|
|
|
|
/* Not quiet yet. Wait more */
|
|
|
|
goto plug_and_out;
|
|
|
|
|
|
|
|
/* This device should be quiet now */
|
|
|
|
__stop_queue(q);
|
|
|
|
blk_start_request(rq);
|
|
|
|
__blk_end_request_all(rq, 0);
|
|
|
|
wake_up(&md->wait);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ti = dm_table_find_target(map, blk_rq_pos(rq));
|
|
|
|
if (ti->type->busy && ti->type->busy(ti))
|
|
|
|
goto plug_and_out;
|
|
|
|
|
|
|
|
blk_start_request(rq);
|
|
|
|
spin_unlock(q->queue_lock);
|
|
|
|
map_request(ti, rq, md);
|
|
|
|
spin_lock_irq(q->queue_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
plug_and_out:
|
|
|
|
if (!elv_queue_empty(q))
|
|
|
|
/* Some requests still remain, retry later */
|
|
|
|
blk_plug_device(q);
|
|
|
|
|
|
|
|
out:
|
|
|
|
dm_table_put(map);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int dm_underlying_device_busy(struct request_queue *q)
|
|
|
|
{
|
|
|
|
return blk_lld_busy(q);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dm_underlying_device_busy);
|
|
|
|
|
|
|
|
static int dm_lld_busy(struct request_queue *q)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
struct mapped_device *md = q->queuedata;
|
|
|
|
struct dm_table *map = dm_get_table(md);
|
|
|
|
|
|
|
|
if (!map || test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))
|
|
|
|
r = 1;
|
|
|
|
else
|
|
|
|
r = dm_table_any_busy_target(map);
|
|
|
|
|
|
|
|
dm_table_put(map);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-07-24 07:28:11 +00:00
|
|
|
static void dm_unplug_all(struct request_queue *q)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct mapped_device *md = q->queuedata;
|
|
|
|
struct dm_table *map = dm_get_table(md);
|
|
|
|
|
|
|
|
if (map) {
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
if (dm_request_based(md))
|
|
|
|
generic_unplug_device(q);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_table_unplug_all(map);
|
|
|
|
dm_table_put(map);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dm_any_congested(void *congested_data, int bdi_bits)
|
|
|
|
{
|
2008-11-13 23:39:14 +00:00
|
|
|
int r = bdi_bits;
|
|
|
|
struct mapped_device *md = congested_data;
|
|
|
|
struct dm_table *map;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:14 +00:00
|
|
|
if (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
|
2008-11-13 23:39:14 +00:00
|
|
|
map = dm_get_table(md);
|
|
|
|
if (map) {
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
/*
|
|
|
|
* Request-based dm cares about only own queue for
|
|
|
|
* the query about congestion status of request_queue
|
|
|
|
*/
|
|
|
|
if (dm_request_based(md))
|
|
|
|
r = md->queue->backing_dev_info.state &
|
|
|
|
bdi_bits;
|
|
|
|
else
|
|
|
|
r = dm_table_any_congested(map, bdi_bits);
|
|
|
|
|
2008-11-13 23:39:14 +00:00
|
|
|
dm_table_put(map);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* An IDR is used to keep track of allocated minor numbers.
|
|
|
|
*---------------------------------------------------------------*/
|
|
|
|
static DEFINE_IDR(_minor_idr);
|
|
|
|
|
2006-06-26 07:27:32 +00:00
|
|
|
static void free_minor(int minor)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_lock(&_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
idr_remove(&_minor_idr, minor);
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_unlock(&_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the device with a specific minor # is free.
|
|
|
|
*/
|
2008-04-24 21:10:59 +00:00
|
|
|
static int specific_minor(int minor)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int r, m;
|
|
|
|
|
|
|
|
if (minor >= (1 << MINORBITS))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2006-06-26 07:27:21 +00:00
|
|
|
r = idr_pre_get(&_minor_idr, GFP_KERNEL);
|
|
|
|
if (!r)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_lock(&_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (idr_find(&_minor_idr, minor)) {
|
|
|
|
r = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:27:21 +00:00
|
|
|
r = idr_get_new_above(&_minor_idr, MINOR_ALLOCED, minor, &m);
|
2006-06-26 07:27:21 +00:00
|
|
|
if (r)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (m != minor) {
|
|
|
|
idr_remove(&_minor_idr, m);
|
|
|
|
r = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_unlock(&_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2008-04-24 21:10:59 +00:00
|
|
|
static int next_free_minor(int *minor)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-06-26 07:27:32 +00:00
|
|
|
int r, m;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
r = idr_pre_get(&_minor_idr, GFP_KERNEL);
|
2006-06-26 07:27:21 +00:00
|
|
|
if (!r)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_lock(&_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-26 07:27:21 +00:00
|
|
|
r = idr_get_new(&_minor_idr, MINOR_ALLOCED, &m);
|
2008-04-24 21:10:59 +00:00
|
|
|
if (r)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (m >= (1 << MINORBITS)) {
|
|
|
|
idr_remove(&_minor_idr, m);
|
|
|
|
r = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
*minor = m;
|
|
|
|
|
|
|
|
out:
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_unlock(&_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2009-09-22 00:01:13 +00:00
|
|
|
static const struct block_device_operations dm_blk_dops;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-02 18:55:37 +00:00
|
|
|
static void dm_wq_work(struct work_struct *work);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Allocate and initialise a blank device with a given minor.
|
|
|
|
*/
|
2006-06-26 07:27:32 +00:00
|
|
|
static struct mapped_device *alloc_dev(int minor)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int r;
|
2008-04-24 21:10:59 +00:00
|
|
|
struct mapped_device *md = kzalloc(sizeof(*md), GFP_KERNEL);
|
2006-06-26 07:27:21 +00:00
|
|
|
void *old_md;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!md) {
|
|
|
|
DMWARN("unable to allocate device, out of memory.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:27:25 +00:00
|
|
|
if (!try_module_get(THIS_MODULE))
|
2008-02-08 02:10:19 +00:00
|
|
|
goto bad_module_get;
|
2006-06-26 07:27:25 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* get a minor number for the dev */
|
2006-06-26 07:27:32 +00:00
|
|
|
if (minor == DM_ANY_MINOR)
|
2008-04-24 21:10:59 +00:00
|
|
|
r = next_free_minor(&minor);
|
2006-06-26 07:27:32 +00:00
|
|
|
else
|
2008-04-24 21:10:59 +00:00
|
|
|
r = specific_minor(minor);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (r < 0)
|
2008-02-08 02:10:19 +00:00
|
|
|
goto bad_minor;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
init_rwsem(&md->io_lock);
|
2008-02-08 02:10:08 +00:00
|
|
|
mutex_init(&md->suspend_lock);
|
2009-04-02 18:55:39 +00:00
|
|
|
spin_lock_init(&md->deferred_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
rwlock_init(&md->map_lock);
|
|
|
|
atomic_set(&md->holders, 1);
|
2006-06-26 07:27:34 +00:00
|
|
|
atomic_set(&md->open_count, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_set(&md->event_nr, 0);
|
2007-10-19 21:48:01 +00:00
|
|
|
atomic_set(&md->uevent_seq, 0);
|
|
|
|
INIT_LIST_HEAD(&md->uevent_list);
|
|
|
|
spin_lock_init(&md->uevent_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
md->queue = blk_init_queue(dm_request_fn, NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!md->queue)
|
2008-02-08 02:10:19 +00:00
|
|
|
goto bad_queue;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
/*
|
|
|
|
* Request-based dm devices cannot be stacked on top of bio-based dm
|
|
|
|
* devices. The type of this dm device has not been decided yet,
|
|
|
|
* although we initialized the queue using blk_init_queue().
|
|
|
|
* The type is decided at the first table loading time.
|
|
|
|
* To prevent problematic device stacking, clear the queue flag
|
|
|
|
* for request stacking support until then.
|
|
|
|
*
|
|
|
|
* This queue is new, so no concurrency on the queue_flags.
|
|
|
|
*/
|
|
|
|
queue_flag_clear_unlocked(QUEUE_FLAG_STACKABLE, md->queue);
|
|
|
|
md->saved_make_request_fn = md->queue->make_request_fn;
|
2005-04-16 22:20:36 +00:00
|
|
|
md->queue->queuedata = md;
|
|
|
|
md->queue->backing_dev_info.congested_fn = dm_any_congested;
|
|
|
|
md->queue->backing_dev_info.congested_data = md;
|
|
|
|
blk_queue_make_request(md->queue, dm_request);
|
2006-01-10 09:48:02 +00:00
|
|
|
blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
|
2005-04-16 22:20:36 +00:00
|
|
|
md->queue->unplug_fn = dm_unplug_all;
|
2008-07-21 11:00:37 +00:00
|
|
|
blk_queue_merge_bvec(md->queue, dm_merge_bvec);
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
blk_queue_softirq_done(md->queue, dm_softirq_done);
|
|
|
|
blk_queue_prep_rq(md->queue, dm_prep_fn);
|
|
|
|
blk_queue_lld_busy(md->queue, dm_lld_busy);
|
2006-10-03 08:15:41 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
md->disk = alloc_disk(1);
|
|
|
|
if (!md->disk)
|
2008-02-08 02:10:19 +00:00
|
|
|
goto bad_disk;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
Revert "Seperate read and write statistics of in_flight requests"
This reverts commit a9327cac440be4d8333bba975cbbf76045096275.
Corrado Zoccolo <czoccolo@gmail.com> reports:
"with 2.6.32-rc1 I started getting the following strange output from
"iostat -kx 2":
Linux 2.6.31bisect (et2) 04/10/2009 _i686_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
10,70 0,00 3,16 15,75 0,00 70,38
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 18,22 0,00 0,67 0,01 14,77 0,02
43,94 0,01 10,53 39043915,03 2629219,87
sdb 60,89 9,68 50,79 3,04 1724,43 50,52
65,95 0,70 13,06 488437,47 2629219,87
avg-cpu: %user %nice %system %iowait %steal %idle
2,72 0,00 0,74 0,00 0,00 96,53
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
6,68 0,00 0,99 0,00 0,00 92,33
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
4,40 0,00 0,73 1,47 0,00 93,40
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 4,00 0,00 3,00 0,00 28,00
18,67 0,06 19,50 333,33 100,00
Global values for service time and utilization are garbage. For
interval values, utilization is always 100%, and service time is
higher than normal.
I bisected it down to:
[a9327cac440be4d8333bba975cbbf76045096275] Seperate read and write
statistics of in_flight requests
and verified that reverting just that commit indeed solves the issue
on 2.6.32-rc1."
So until this is debugged, revert the bad commit.
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2009-10-04 19:04:38 +00:00
|
|
|
atomic_set(&md->pending, 0);
|
2006-06-26 07:27:25 +00:00
|
|
|
init_waitqueue_head(&md->wait);
|
2009-04-02 18:55:37 +00:00
|
|
|
INIT_WORK(&md->work, dm_wq_work);
|
2006-06-26 07:27:25 +00:00
|
|
|
init_waitqueue_head(&md->eventq);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
md->disk->major = _major;
|
|
|
|
md->disk->first_minor = minor;
|
|
|
|
md->disk->fops = &dm_blk_dops;
|
|
|
|
md->disk->queue = md->queue;
|
|
|
|
md->disk->private_data = md;
|
|
|
|
sprintf(md->disk->disk_name, "dm-%d", minor);
|
|
|
|
add_disk(md->disk);
|
2006-03-27 09:17:52 +00:00
|
|
|
format_dev_t(md->name, MKDEV(_major, minor));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 02:11:17 +00:00
|
|
|
md->wq = create_singlethread_workqueue("kdmflush");
|
|
|
|
if (!md->wq)
|
|
|
|
goto bad_thread;
|
|
|
|
|
2009-06-22 09:12:17 +00:00
|
|
|
md->bdev = bdget_disk(md->disk, 0);
|
|
|
|
if (!md->bdev)
|
|
|
|
goto bad_bdev;
|
|
|
|
|
2006-06-26 07:27:21 +00:00
|
|
|
/* Populate the mapping, nobody knows we exist yet */
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_lock(&_minor_lock);
|
2006-06-26 07:27:21 +00:00
|
|
|
old_md = idr_replace(&_minor_idr, md, minor);
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_unlock(&_minor_lock);
|
2006-06-26 07:27:21 +00:00
|
|
|
|
|
|
|
BUG_ON(old_md != MINOR_ALLOCED);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return md;
|
|
|
|
|
2009-06-22 09:12:17 +00:00
|
|
|
bad_bdev:
|
|
|
|
destroy_workqueue(md->wq);
|
2008-02-08 02:11:17 +00:00
|
|
|
bad_thread:
|
|
|
|
put_disk(md->disk);
|
2008-02-08 02:10:19 +00:00
|
|
|
bad_disk:
|
2006-03-12 16:02:03 +00:00
|
|
|
blk_cleanup_queue(md->queue);
|
2008-02-08 02:10:19 +00:00
|
|
|
bad_queue:
|
2005-04-16 22:20:36 +00:00
|
|
|
free_minor(minor);
|
2008-02-08 02:10:19 +00:00
|
|
|
bad_minor:
|
2006-06-26 07:27:25 +00:00
|
|
|
module_put(THIS_MODULE);
|
2008-02-08 02:10:19 +00:00
|
|
|
bad_module_get:
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(md);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-10-19 21:38:43 +00:00
|
|
|
static void unlock_fs(struct mapped_device *md);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void free_dev(struct mapped_device *md)
|
|
|
|
{
|
2008-09-03 07:01:48 +00:00
|
|
|
int minor = MINOR(disk_devt(md->disk));
|
2006-02-24 21:04:25 +00:00
|
|
|
|
2009-06-22 09:12:17 +00:00
|
|
|
unlock_fs(md);
|
|
|
|
bdput(md->bdev);
|
2008-02-08 02:11:17 +00:00
|
|
|
destroy_workqueue(md->wq);
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
if (md->tio_pool)
|
|
|
|
mempool_destroy(md->tio_pool);
|
|
|
|
if (md->io_pool)
|
|
|
|
mempool_destroy(md->io_pool);
|
|
|
|
if (md->bs)
|
|
|
|
bioset_free(md->bs);
|
2009-04-08 23:27:12 +00:00
|
|
|
blk_integrity_unregister(md->disk);
|
2005-04-16 22:20:36 +00:00
|
|
|
del_gendisk(md->disk);
|
2006-02-24 21:04:25 +00:00
|
|
|
free_minor(minor);
|
2006-06-26 07:27:23 +00:00
|
|
|
|
|
|
|
spin_lock(&_minor_lock);
|
|
|
|
md->disk->private_data = NULL;
|
|
|
|
spin_unlock(&_minor_lock);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
put_disk(md->disk);
|
2006-03-12 16:02:03 +00:00
|
|
|
blk_cleanup_queue(md->queue);
|
2006-06-26 07:27:25 +00:00
|
|
|
module_put(THIS_MODULE);
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(md);
|
|
|
|
}
|
|
|
|
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
static void __bind_mempools(struct mapped_device *md, struct dm_table *t)
|
|
|
|
{
|
|
|
|
struct dm_md_mempools *p;
|
|
|
|
|
|
|
|
if (md->io_pool && md->tio_pool && md->bs)
|
|
|
|
/* the md already has necessary mempools */
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
p = dm_table_get_md_mempools(t);
|
|
|
|
BUG_ON(!p || md->io_pool || md->tio_pool || md->bs);
|
|
|
|
|
|
|
|
md->io_pool = p->io_pool;
|
|
|
|
p->io_pool = NULL;
|
|
|
|
md->tio_pool = p->tio_pool;
|
|
|
|
p->tio_pool = NULL;
|
|
|
|
md->bs = p->bs;
|
|
|
|
p->bs = NULL;
|
|
|
|
|
|
|
|
out:
|
|
|
|
/* mempool bind completed, now no need any mempools in the table */
|
|
|
|
dm_table_free_md_mempools(t);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Bind a table to the device.
|
|
|
|
*/
|
|
|
|
static void event_callback(void *context)
|
|
|
|
{
|
2007-10-19 21:48:01 +00:00
|
|
|
unsigned long flags;
|
|
|
|
LIST_HEAD(uevents);
|
2005-04-16 22:20:36 +00:00
|
|
|
struct mapped_device *md = (struct mapped_device *) context;
|
|
|
|
|
2007-10-19 21:48:01 +00:00
|
|
|
spin_lock_irqsave(&md->uevent_lock, flags);
|
|
|
|
list_splice_init(&md->uevent_list, &uevents);
|
|
|
|
spin_unlock_irqrestore(&md->uevent_lock, flags);
|
|
|
|
|
2008-08-25 10:56:05 +00:00
|
|
|
dm_send_uevents(&uevents, &disk_to_dev(md->disk)->kobj);
|
2007-10-19 21:48:01 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
atomic_inc(&md->event_nr);
|
|
|
|
wake_up(&md->eventq);
|
|
|
|
}
|
|
|
|
|
2005-07-29 04:15:59 +00:00
|
|
|
static void __set_size(struct mapped_device *md, sector_t size)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-07-29 04:15:59 +00:00
|
|
|
set_capacity(md->disk, size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-22 09:12:15 +00:00
|
|
|
mutex_lock(&md->bdev->bd_inode->i_mutex);
|
|
|
|
i_size_write(md->bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
|
|
|
|
mutex_unlock(&md->bdev->bd_inode->i_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-06-22 09:12:34 +00:00
|
|
|
static int __bind(struct mapped_device *md, struct dm_table *t,
|
|
|
|
struct queue_limits *limits)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-07-24 07:28:11 +00:00
|
|
|
struct request_queue *q = md->queue;
|
2005-04-16 22:20:36 +00:00
|
|
|
sector_t size;
|
2009-06-22 09:12:37 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
size = dm_table_get_size(t);
|
2006-03-27 09:17:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Wipe any geometry if the size of the table changed.
|
|
|
|
*/
|
|
|
|
if (size != get_capacity(md->disk))
|
|
|
|
memset(&md->geometry, 0, sizeof(md->geometry));
|
|
|
|
|
2009-06-22 09:12:17 +00:00
|
|
|
__set_size(md, size);
|
dm table: rework reference counting
Rework table reference counting.
The existing code uses a reference counter. When the last reference is
dropped and the counter reaches zero, the table destructor is called.
Table reference counters are acquired/released from upcalls from other
kernel code (dm_any_congested, dm_merge_bvec, dm_unplug_all).
If the reference counter reaches zero in one of the upcalls, the table
destructor is called from almost random kernel code.
This leads to various problems:
* dm_any_congested being called under a spinlock, which calls the
destructor, which calls some sleeping function.
* the destructor attempting to take a lock that is already taken by the
same process.
* stale reference from some other kernel code keeps the table
constructed, which keeps some devices open, even after successful
return from "dmsetup remove". This can confuse lvm and prevent closing
of underlying devices or reusing device minor numbers.
The patch changes reference counting so that the table destructor can be
called only at predetermined places.
The table has always exactly one reference from either mapped_device->map
or hash_cell->new_map. After this patch, this reference is not counted
in table->holders. A pair of dm_create_table/dm_destroy_table functions
is used for table creation/destruction.
Temporary references from the other code increase table->holders. A pair
of dm_table_get/dm_table_put functions is used to manipulate it.
When the table is about to be destroyed, we wait for table->holders to
reach 0. Then, we call the table destructor. We use active waiting with
msleep(1), because the situation happens rarely (to one user in 5 years)
and removing the device isn't performance-critical task: the user doesn't
care if it takes one tick more or not.
This way, the destructor is called only at specific points
(dm_table_destroy function) and the above problems associated with lazy
destruction can't happen.
Finally remove the temporary protection added to dm_any_congested().
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-01-06 03:05:10 +00:00
|
|
|
|
|
|
|
if (!size) {
|
|
|
|
dm_table_destroy(t);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
dm table: rework reference counting
Rework table reference counting.
The existing code uses a reference counter. When the last reference is
dropped and the counter reaches zero, the table destructor is called.
Table reference counters are acquired/released from upcalls from other
kernel code (dm_any_congested, dm_merge_bvec, dm_unplug_all).
If the reference counter reaches zero in one of the upcalls, the table
destructor is called from almost random kernel code.
This leads to various problems:
* dm_any_congested being called under a spinlock, which calls the
destructor, which calls some sleeping function.
* the destructor attempting to take a lock that is already taken by the
same process.
* stale reference from some other kernel code keeps the table
constructed, which keeps some devices open, even after successful
return from "dmsetup remove". This can confuse lvm and prevent closing
of underlying devices or reusing device minor numbers.
The patch changes reference counting so that the table destructor can be
called only at predetermined places.
The table has always exactly one reference from either mapped_device->map
or hash_cell->new_map. After this patch, this reference is not counted
in table->holders. A pair of dm_create_table/dm_destroy_table functions
is used for table creation/destruction.
Temporary references from the other code increase table->holders. A pair
of dm_table_get/dm_table_put functions is used to manipulate it.
When the table is about to be destroyed, we wait for table->holders to
reach 0. Then, we call the table destructor. We use active waiting with
msleep(1), because the situation happens rarely (to one user in 5 years)
and removing the device isn't performance-critical task: the user doesn't
care if it takes one tick more or not.
This way, the destructor is called only at specific points
(dm_table_destroy function) and the above problems associated with lazy
destruction can't happen.
Finally remove the temporary protection added to dm_any_congested().
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-01-06 03:05:10 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
dm_table_event_callback(t, event_callback, md);
|
|
|
|
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
/*
|
|
|
|
* The queue hasn't been stopped yet, if the old table type wasn't
|
|
|
|
* for request-based during suspension. So stop it to prevent
|
|
|
|
* I/O mapping before resume.
|
|
|
|
* This must be done before setting the queue restrictions,
|
|
|
|
* because request-based dm may be run just after the setting.
|
|
|
|
*/
|
|
|
|
if (dm_table_request_based(t) && !blk_queue_stopped(q))
|
|
|
|
stop_queue(q);
|
|
|
|
|
|
|
|
__bind_mempools(md, t);
|
|
|
|
|
2009-06-22 09:12:37 +00:00
|
|
|
write_lock_irqsave(&md->map_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
md->map = t;
|
2009-06-22 09:12:34 +00:00
|
|
|
dm_table_set_restrictions(t, q, limits);
|
2009-06-22 09:12:37 +00:00
|
|
|
write_unlock_irqrestore(&md->map_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __unbind(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
struct dm_table *map = md->map;
|
2009-06-22 09:12:37 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!map)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dm_table_event_callback(map, NULL, NULL);
|
2009-06-22 09:12:37 +00:00
|
|
|
write_lock_irqsave(&md->map_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
md->map = NULL;
|
2009-06-22 09:12:37 +00:00
|
|
|
write_unlock_irqrestore(&md->map_lock, flags);
|
dm table: rework reference counting
Rework table reference counting.
The existing code uses a reference counter. When the last reference is
dropped and the counter reaches zero, the table destructor is called.
Table reference counters are acquired/released from upcalls from other
kernel code (dm_any_congested, dm_merge_bvec, dm_unplug_all).
If the reference counter reaches zero in one of the upcalls, the table
destructor is called from almost random kernel code.
This leads to various problems:
* dm_any_congested being called under a spinlock, which calls the
destructor, which calls some sleeping function.
* the destructor attempting to take a lock that is already taken by the
same process.
* stale reference from some other kernel code keeps the table
constructed, which keeps some devices open, even after successful
return from "dmsetup remove". This can confuse lvm and prevent closing
of underlying devices or reusing device minor numbers.
The patch changes reference counting so that the table destructor can be
called only at predetermined places.
The table has always exactly one reference from either mapped_device->map
or hash_cell->new_map. After this patch, this reference is not counted
in table->holders. A pair of dm_create_table/dm_destroy_table functions
is used for table creation/destruction.
Temporary references from the other code increase table->holders. A pair
of dm_table_get/dm_table_put functions is used to manipulate it.
When the table is about to be destroyed, we wait for table->holders to
reach 0. Then, we call the table destructor. We use active waiting with
msleep(1), because the situation happens rarely (to one user in 5 years)
and removing the device isn't performance-critical task: the user doesn't
care if it takes one tick more or not.
This way, the destructor is called only at specific points
(dm_table_destroy function) and the above problems associated with lazy
destruction can't happen.
Finally remove the temporary protection added to dm_any_congested().
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-01-06 03:05:10 +00:00
|
|
|
dm_table_destroy(map);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Constructor for a new device.
|
|
|
|
*/
|
2006-06-26 07:27:32 +00:00
|
|
|
int dm_create(int minor, struct mapped_device **result)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct mapped_device *md;
|
|
|
|
|
2006-06-26 07:27:32 +00:00
|
|
|
md = alloc_dev(minor);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!md)
|
|
|
|
return -ENXIO;
|
|
|
|
|
2009-01-06 03:05:12 +00:00
|
|
|
dm_sysfs_init(md);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
*result = md;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-06 08:20:00 +00:00
|
|
|
static struct mapped_device *dm_find_md(dev_t dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct mapped_device *md;
|
|
|
|
unsigned minor = MINOR(dev);
|
|
|
|
|
|
|
|
if (MAJOR(dev) != _major || minor >= (1 << MINORBITS))
|
|
|
|
return NULL;
|
|
|
|
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_lock(&_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
md = idr_find(&_minor_idr, minor);
|
2006-06-26 07:27:23 +00:00
|
|
|
if (md && (md == MINOR_ALLOCED ||
|
2008-09-03 07:01:48 +00:00
|
|
|
(MINOR(disk_devt(dm_disk(md))) != minor) ||
|
2006-06-26 07:27:33 +00:00
|
|
|
test_bit(DMF_FREEING, &md->flags))) {
|
2006-01-06 08:20:00 +00:00
|
|
|
md = NULL;
|
2006-06-26 07:27:23 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-26 07:27:23 +00:00
|
|
|
out:
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_unlock(&_minor_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-06 08:20:00 +00:00
|
|
|
return md;
|
|
|
|
}
|
|
|
|
|
2006-01-06 08:20:01 +00:00
|
|
|
struct mapped_device *dm_get_md(dev_t dev)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = dm_find_md(dev);
|
|
|
|
|
|
|
|
if (md)
|
|
|
|
dm_get(md);
|
|
|
|
|
|
|
|
return md;
|
|
|
|
}
|
|
|
|
|
2006-03-27 09:17:53 +00:00
|
|
|
void *dm_get_mdptr(struct mapped_device *md)
|
2006-01-06 08:20:00 +00:00
|
|
|
{
|
2006-03-27 09:17:53 +00:00
|
|
|
return md->interface_ptr;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void dm_set_mdptr(struct mapped_device *md, void *ptr)
|
|
|
|
{
|
|
|
|
md->interface_ptr = ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void dm_get(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
atomic_inc(&md->holders);
|
|
|
|
}
|
|
|
|
|
2006-06-26 07:27:35 +00:00
|
|
|
const char *dm_device_name(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return md->name;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dm_device_name);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void dm_put(struct mapped_device *md)
|
|
|
|
{
|
2006-03-27 09:17:54 +00:00
|
|
|
struct dm_table *map;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-26 07:27:23 +00:00
|
|
|
BUG_ON(test_bit(DMF_FREEING, &md->flags));
|
|
|
|
|
2006-06-26 07:27:22 +00:00
|
|
|
if (atomic_dec_and_lock(&md->holders, &_minor_lock)) {
|
2006-03-27 09:17:54 +00:00
|
|
|
map = dm_get_table(md);
|
2008-09-03 07:01:48 +00:00
|
|
|
idr_replace(&_minor_idr, MINOR_ALLOCED,
|
|
|
|
MINOR(disk_devt(dm_disk(md))));
|
2006-06-26 07:27:23 +00:00
|
|
|
set_bit(DMF_FREEING, &md->flags);
|
2006-06-26 07:27:22 +00:00
|
|
|
spin_unlock(&_minor_lock);
|
2005-07-29 04:15:57 +00:00
|
|
|
if (!dm_suspended(md)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_table_presuspend_targets(map);
|
|
|
|
dm_table_postsuspend_targets(map);
|
|
|
|
}
|
2009-01-06 03:05:12 +00:00
|
|
|
dm_sysfs_exit(md);
|
2006-03-27 09:17:54 +00:00
|
|
|
dm_table_put(map);
|
2009-01-06 03:04:53 +00:00
|
|
|
__unbind(md);
|
2005-04-16 22:20:36 +00:00
|
|
|
free_dev(md);
|
|
|
|
}
|
|
|
|
}
|
2007-05-09 09:32:56 +00:00
|
|
|
EXPORT_SYMBOL_GPL(dm_put);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-02 18:55:38 +00:00
|
|
|
static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
|
2008-02-08 02:10:30 +00:00
|
|
|
{
|
|
|
|
int r = 0;
|
2009-04-02 18:55:39 +00:00
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
struct request_queue *q = md->queue;
|
|
|
|
unsigned long flags;
|
2009-04-02 18:55:39 +00:00
|
|
|
|
|
|
|
dm_unplug_all(md->queue);
|
|
|
|
|
|
|
|
add_wait_queue(&md->wait, &wait);
|
2008-02-08 02:10:30 +00:00
|
|
|
|
|
|
|
while (1) {
|
2009-04-02 18:55:38 +00:00
|
|
|
set_current_state(interruptible);
|
2008-02-08 02:10:30 +00:00
|
|
|
|
|
|
|
smp_mb();
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
if (dm_request_based(md)) {
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
if (!queue_in_flight(q) && blk_queue_stopped(q)) {
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
Revert "Seperate read and write statistics of in_flight requests"
This reverts commit a9327cac440be4d8333bba975cbbf76045096275.
Corrado Zoccolo <czoccolo@gmail.com> reports:
"with 2.6.32-rc1 I started getting the following strange output from
"iostat -kx 2":
Linux 2.6.31bisect (et2) 04/10/2009 _i686_ (2 CPU)
avg-cpu: %user %nice %system %iowait %steal %idle
10,70 0,00 3,16 15,75 0,00 70,38
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 18,22 0,00 0,67 0,01 14,77 0,02
43,94 0,01 10,53 39043915,03 2629219,87
sdb 60,89 9,68 50,79 3,04 1724,43 50,52
65,95 0,70 13,06 488437,47 2629219,87
avg-cpu: %user %nice %system %iowait %steal %idle
2,72 0,00 0,74 0,00 0,00 96,53
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
6,68 0,00 0,99 0,00 0,00 92,33
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
avg-cpu: %user %nice %system %iowait %steal %idle
4,40 0,00 0,73 1,47 0,00 93,40
Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s
avgrq-sz avgqu-sz await svctm %util
sda 0,00 0,00 0,00 0,00 0,00 0,00
0,00 0,00 0,00 0,00 100,00
sdb 0,00 4,00 0,00 3,00 0,00 28,00
18,67 0,06 19,50 333,33 100,00
Global values for service time and utilization are garbage. For
interval values, utilization is always 100%, and service time is
higher than normal.
I bisected it down to:
[a9327cac440be4d8333bba975cbbf76045096275] Seperate read and write
statistics of in_flight requests
and verified that reverting just that commit indeed solves the issue
on 2.6.32-rc1."
So until this is debugged, revert the bad commit.
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
2009-10-04 19:04:38 +00:00
|
|
|
} else if (!atomic_read(&md->pending))
|
2008-02-08 02:10:30 +00:00
|
|
|
break;
|
|
|
|
|
2009-04-02 18:55:38 +00:00
|
|
|
if (interruptible == TASK_INTERRUPTIBLE &&
|
|
|
|
signal_pending(current)) {
|
2008-02-08 02:10:30 +00:00
|
|
|
r = -EINTR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
io_schedule();
|
|
|
|
}
|
|
|
|
set_current_state(TASK_RUNNING);
|
|
|
|
|
2009-04-02 18:55:39 +00:00
|
|
|
remove_wait_queue(&md->wait, &wait);
|
|
|
|
|
2008-02-08 02:10:30 +00:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2009-06-22 09:12:17 +00:00
|
|
|
static void dm_flush(struct mapped_device *md)
|
2009-04-08 23:27:16 +00:00
|
|
|
{
|
|
|
|
dm_wait_for_completion(md, TASK_UNINTERRUPTIBLE);
|
2009-06-22 09:12:21 +00:00
|
|
|
|
|
|
|
bio_init(&md->barrier_bio);
|
|
|
|
md->barrier_bio.bi_bdev = md->bdev;
|
|
|
|
md->barrier_bio.bi_rw = WRITE_BARRIER;
|
|
|
|
__split_and_process_bio(md, &md->barrier_bio);
|
|
|
|
|
|
|
|
dm_wait_for_completion(md, TASK_UNINTERRUPTIBLE);
|
2009-04-08 23:27:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void process_barrier(struct mapped_device *md, struct bio *bio)
|
|
|
|
{
|
2009-06-22 09:12:18 +00:00
|
|
|
md->barrier_error = 0;
|
|
|
|
|
2009-06-22 09:12:17 +00:00
|
|
|
dm_flush(md);
|
2009-04-08 23:27:16 +00:00
|
|
|
|
2009-06-22 09:12:18 +00:00
|
|
|
if (!bio_empty_barrier(bio)) {
|
|
|
|
__split_and_process_bio(md, bio);
|
|
|
|
dm_flush(md);
|
2009-04-08 23:27:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (md->barrier_error != DM_ENDIO_REQUEUE)
|
2009-06-22 09:12:17 +00:00
|
|
|
bio_endio(bio, md->barrier_error);
|
2009-06-22 09:12:18 +00:00
|
|
|
else {
|
|
|
|
spin_lock_irq(&md->deferred_lock);
|
|
|
|
bio_list_add_head(&md->deferred, bio);
|
|
|
|
spin_unlock_irq(&md->deferred_lock);
|
|
|
|
}
|
2009-04-08 23:27:16 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Process the deferred bios
|
|
|
|
*/
|
2009-04-02 18:55:38 +00:00
|
|
|
static void dm_wq_work(struct work_struct *work)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-04-02 18:55:38 +00:00
|
|
|
struct mapped_device *md = container_of(work, struct mapped_device,
|
|
|
|
work);
|
2008-02-08 02:10:22 +00:00
|
|
|
struct bio *c;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-02 18:55:38 +00:00
|
|
|
down_write(&md->io_lock);
|
|
|
|
|
2009-04-08 23:27:15 +00:00
|
|
|
while (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
|
2009-04-08 23:27:13 +00:00
|
|
|
spin_lock_irq(&md->deferred_lock);
|
|
|
|
c = bio_list_pop(&md->deferred);
|
|
|
|
spin_unlock_irq(&md->deferred_lock);
|
|
|
|
|
|
|
|
if (!c) {
|
2009-04-08 23:27:14 +00:00
|
|
|
clear_bit(DMF_QUEUE_IO_TO_THREAD, &md->flags);
|
2009-04-08 23:27:13 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-04-02 18:55:39 +00:00
|
|
|
|
2009-04-08 23:27:15 +00:00
|
|
|
up_write(&md->io_lock);
|
|
|
|
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
if (dm_request_based(md))
|
|
|
|
generic_make_request(c);
|
|
|
|
else {
|
2009-09-11 12:32:04 +00:00
|
|
|
if (bio_rw_flagged(c, BIO_RW_BARRIER))
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
process_barrier(md, c);
|
|
|
|
else
|
|
|
|
__split_and_process_bio(md, c);
|
|
|
|
}
|
2009-04-08 23:27:15 +00:00
|
|
|
|
|
|
|
down_write(&md->io_lock);
|
2009-04-02 18:55:39 +00:00
|
|
|
}
|
2008-02-08 02:10:25 +00:00
|
|
|
|
2009-04-02 18:55:38 +00:00
|
|
|
up_write(&md->io_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-04-02 18:55:36 +00:00
|
|
|
static void dm_queue_flush(struct mapped_device *md)
|
2008-02-08 02:11:17 +00:00
|
|
|
{
|
2009-04-08 23:27:15 +00:00
|
|
|
clear_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
|
|
|
|
smp_mb__after_clear_bit();
|
2009-04-02 18:55:37 +00:00
|
|
|
queue_work(md->wq, &md->work);
|
2008-02-08 02:11:17 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Swap in a new table (destroying old one).
|
|
|
|
*/
|
|
|
|
int dm_swap_table(struct mapped_device *md, struct dm_table *table)
|
|
|
|
{
|
2009-06-22 09:12:34 +00:00
|
|
|
struct queue_limits limits;
|
2005-07-12 22:53:05 +00:00
|
|
|
int r = -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 02:10:08 +00:00
|
|
|
mutex_lock(&md->suspend_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* device must be suspended */
|
2005-07-29 04:15:57 +00:00
|
|
|
if (!dm_suspended(md))
|
2005-07-12 22:53:05 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-06-22 09:12:34 +00:00
|
|
|
r = dm_calculate_queue_limits(table, &limits);
|
|
|
|
if (r)
|
|
|
|
goto out;
|
|
|
|
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
/* cannot change the device type, once a table is bound */
|
|
|
|
if (md->map &&
|
|
|
|
(dm_table_get_type(md->map) != dm_table_get_type(table))) {
|
|
|
|
DMWARN("can't change the device type after a table is bound");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
__unbind(md);
|
2009-06-22 09:12:34 +00:00
|
|
|
r = __bind(md, table, &limits);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-07-12 22:53:05 +00:00
|
|
|
out:
|
2008-02-08 02:10:08 +00:00
|
|
|
mutex_unlock(&md->suspend_lock);
|
2005-07-12 22:53:05 +00:00
|
|
|
return r;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
static void dm_rq_invalidate_suspend_marker(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
md->suspend_rq.special = (void *)0x1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dm_rq_abort_suspend(struct mapped_device *md, int noflush)
|
|
|
|
{
|
|
|
|
struct request_queue *q = md->queue;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
if (!noflush)
|
|
|
|
dm_rq_invalidate_suspend_marker(md);
|
|
|
|
__start_queue(q);
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dm_rq_start_suspend(struct mapped_device *md, int noflush)
|
|
|
|
{
|
|
|
|
struct request *rq = &md->suspend_rq;
|
|
|
|
struct request_queue *q = md->queue;
|
|
|
|
|
|
|
|
if (noflush)
|
|
|
|
stop_queue(q);
|
|
|
|
else {
|
|
|
|
blk_rq_init(q, rq);
|
|
|
|
blk_insert_request(q, rq, 0, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dm_rq_suspend_available(struct mapped_device *md, int noflush)
|
|
|
|
{
|
|
|
|
int r = 1;
|
|
|
|
struct request *rq = &md->suspend_rq;
|
|
|
|
struct request_queue *q = md->queue;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (noflush)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
/* The marker must be protected by queue lock if it is in use */
|
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
|
|
|
if (unlikely(rq->ref_count)) {
|
|
|
|
/*
|
|
|
|
* This can happen, when the previous flush suspend was
|
|
|
|
* interrupted, the marker is still in the queue and
|
|
|
|
* this flush suspend has been invoked, because we don't
|
|
|
|
* remove the marker at the time of suspend interruption.
|
|
|
|
* We have only one marker per mapped_device, so we can't
|
|
|
|
* start another flush suspend while it is in use.
|
|
|
|
*/
|
|
|
|
BUG_ON(!rq->special); /* The marker should be invalidated */
|
|
|
|
DMWARN("Invalidating the previous flush suspend is still in"
|
|
|
|
" progress. Please retry later.");
|
|
|
|
r = 0;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Functions to lock and unlock any filesystem running on the
|
|
|
|
* device.
|
|
|
|
*/
|
2005-07-29 04:16:00 +00:00
|
|
|
static int lock_fs(struct mapped_device *md)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-01-06 08:20:05 +00:00
|
|
|
int r;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
WARN_ON(md->frozen_sb);
|
2005-05-05 23:16:04 +00:00
|
|
|
|
2009-06-22 09:12:15 +00:00
|
|
|
md->frozen_sb = freeze_bdev(md->bdev);
|
2005-05-05 23:16:04 +00:00
|
|
|
if (IS_ERR(md->frozen_sb)) {
|
2005-07-29 04:15:57 +00:00
|
|
|
r = PTR_ERR(md->frozen_sb);
|
2006-01-06 08:20:05 +00:00
|
|
|
md->frozen_sb = NULL;
|
|
|
|
return r;
|
2005-05-05 23:16:04 +00:00
|
|
|
}
|
|
|
|
|
2006-01-06 08:20:06 +00:00
|
|
|
set_bit(DMF_FROZEN, &md->flags);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
static void unlock_fs(struct mapped_device *md)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-01-06 08:20:06 +00:00
|
|
|
if (!test_bit(DMF_FROZEN, &md->flags))
|
|
|
|
return;
|
|
|
|
|
2009-06-22 09:12:15 +00:00
|
|
|
thaw_bdev(md->bdev, md->frozen_sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
md->frozen_sb = NULL;
|
2006-01-06 08:20:06 +00:00
|
|
|
clear_bit(DMF_FROZEN, &md->flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to be able to change a mapping table under a mounted
|
|
|
|
* filesystem. For example we might want to move some data in
|
|
|
|
* the background. Before the table can be swapped with
|
|
|
|
* dm_bind_table, dm_suspend must be called to flush any in
|
|
|
|
* flight bios and ensure that any further io gets deferred.
|
|
|
|
*/
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
/*
|
|
|
|
* Suspend mechanism in request-based dm.
|
|
|
|
*
|
|
|
|
* After the suspend starts, further incoming requests are kept in
|
|
|
|
* the request_queue and deferred.
|
|
|
|
* Remaining requests in the request_queue at the start of suspend are flushed
|
|
|
|
* if it is flush suspend.
|
|
|
|
* The suspend completes when the following conditions have been satisfied,
|
|
|
|
* so wait for it:
|
|
|
|
* 1. q->in_flight is 0 (which means no in_flight request)
|
|
|
|
* 2. queue has been stopped (which means no request dispatching)
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Noflush suspend
|
|
|
|
* ---------------
|
|
|
|
* Noflush suspend doesn't need to dispatch remaining requests.
|
|
|
|
* So stop the queue immediately. Then, wait for all in_flight requests
|
|
|
|
* to be completed or requeued.
|
|
|
|
*
|
|
|
|
* To abort noflush suspend, start the queue.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Flush suspend
|
|
|
|
* -------------
|
|
|
|
* Flush suspend needs to dispatch remaining requests. So stop the queue
|
|
|
|
* after the remaining requests are completed. (Requeued request must be also
|
|
|
|
* re-dispatched and completed. Until then, we can't stop the queue.)
|
|
|
|
*
|
|
|
|
* During flushing the remaining requests, further incoming requests are also
|
|
|
|
* inserted to the same queue. To distinguish which requests are to be
|
|
|
|
* flushed, we insert a marker request to the queue at the time of starting
|
|
|
|
* flush suspend, like a barrier.
|
|
|
|
* The dispatching is blocked when the marker is found on the top of the queue.
|
|
|
|
* And the queue is stopped when all in_flight requests are completed, since
|
|
|
|
* that means the remaining requests are completely flushed.
|
|
|
|
* Then, the marker is removed from the queue.
|
|
|
|
*
|
|
|
|
* To abort flush suspend, we also need to take care of the marker, not only
|
|
|
|
* starting the queue.
|
|
|
|
* We don't remove the marker forcibly from the queue since it's against
|
|
|
|
* the block-layer manner. Instead, we put a invalidated mark on the marker.
|
|
|
|
* When the invalidated marker is found on the top of the queue, it is
|
|
|
|
* immediately removed from the queue, so it doesn't block dispatching.
|
|
|
|
* Because we have only one marker per mapped_device, we can't start another
|
|
|
|
* flush suspend until the invalidated marker is removed from the queue.
|
|
|
|
* So fail and return with -EBUSY in such a case.
|
|
|
|
*/
|
2006-12-08 10:41:04 +00:00
|
|
|
int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-07-29 04:16:00 +00:00
|
|
|
struct dm_table *map = NULL;
|
2008-02-08 02:10:30 +00:00
|
|
|
int r = 0;
|
2006-12-08 10:41:04 +00:00
|
|
|
int do_lockfs = suspend_flags & DM_SUSPEND_LOCKFS_FLAG ? 1 : 0;
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
int noflush = suspend_flags & DM_SUSPEND_NOFLUSH_FLAG ? 1 : 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 02:10:08 +00:00
|
|
|
mutex_lock(&md->suspend_lock);
|
2005-07-29 04:16:00 +00:00
|
|
|
|
2008-02-08 02:10:25 +00:00
|
|
|
if (dm_suspended(md)) {
|
|
|
|
r = -EINVAL;
|
2006-11-09 01:44:43 +00:00
|
|
|
goto out_unlock;
|
2008-02-08 02:10:25 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
if (dm_request_based(md) && !dm_rq_suspend_available(md, noflush)) {
|
|
|
|
r = -EBUSY;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
map = dm_get_table(md);
|
|
|
|
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
/*
|
|
|
|
* DMF_NOFLUSH_SUSPENDING must be set before presuspend.
|
|
|
|
* This flag is cleared before dm_suspend returns.
|
|
|
|
*/
|
|
|
|
if (noflush)
|
|
|
|
set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
|
|
|
|
|
2005-07-29 04:15:57 +00:00
|
|
|
/* This does not get reverted if there's an error later. */
|
|
|
|
dm_table_presuspend_targets(map);
|
|
|
|
|
2009-06-22 09:12:17 +00:00
|
|
|
/*
|
|
|
|
* Flush I/O to the device. noflush supersedes do_lockfs,
|
|
|
|
* because lock_fs() needs to flush I/Os.
|
|
|
|
*/
|
|
|
|
if (!noflush && do_lockfs) {
|
|
|
|
r = lock_fs(md);
|
|
|
|
if (r)
|
2008-10-21 16:45:07 +00:00
|
|
|
goto out;
|
2006-01-06 08:20:06 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2009-04-08 23:27:15 +00:00
|
|
|
* Here we must make sure that no processes are submitting requests
|
|
|
|
* to target drivers i.e. no one may be executing
|
|
|
|
* __split_and_process_bio. This is called from dm_request and
|
|
|
|
* dm_wq_work.
|
|
|
|
*
|
|
|
|
* To get all processes out of __split_and_process_bio in dm_request,
|
|
|
|
* we take the write lock. To prevent any process from reentering
|
|
|
|
* __split_and_process_bio from dm_request, we set
|
|
|
|
* DMF_QUEUE_IO_TO_THREAD.
|
|
|
|
*
|
|
|
|
* To quiesce the thread (dm_wq_work), we set DMF_BLOCK_IO_FOR_SUSPEND
|
|
|
|
* and call flush_workqueue(md->wq). flush_workqueue will wait until
|
|
|
|
* dm_wq_work exits and DMF_BLOCK_IO_FOR_SUSPEND will prevent any
|
|
|
|
* further calls to __split_and_process_bio from dm_wq_work.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2005-07-29 04:16:00 +00:00
|
|
|
down_write(&md->io_lock);
|
2009-04-08 23:27:14 +00:00
|
|
|
set_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags);
|
|
|
|
set_bit(DMF_QUEUE_IO_TO_THREAD, &md->flags);
|
2005-07-29 04:16:00 +00:00
|
|
|
up_write(&md->io_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:15 +00:00
|
|
|
flush_workqueue(md->wq);
|
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
if (dm_request_based(md))
|
|
|
|
dm_rq_start_suspend(md, noflush);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2009-04-08 23:27:15 +00:00
|
|
|
* At this point no more requests are entering target request routines.
|
|
|
|
* We call dm_wait_for_completion to wait for all existing requests
|
|
|
|
* to finish.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-04-02 18:55:38 +00:00
|
|
|
r = dm_wait_for_completion(md, TASK_INTERRUPTIBLE);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
down_write(&md->io_lock);
|
2008-02-08 02:10:22 +00:00
|
|
|
if (noflush)
|
2009-04-02 18:55:39 +00:00
|
|
|
clear_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
|
2008-02-08 02:10:27 +00:00
|
|
|
up_write(&md->io_lock);
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* were we interrupted ? */
|
2008-02-08 02:10:30 +00:00
|
|
|
if (r < 0) {
|
2009-04-02 18:55:36 +00:00
|
|
|
dm_queue_flush(md);
|
2008-02-08 02:10:25 +00:00
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
if (dm_request_based(md))
|
|
|
|
dm_rq_abort_suspend(md, noflush);
|
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
unlock_fs(md);
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
goto out; /* pushback list is already flushed, so skip flush */
|
2005-07-29 04:16:00 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-08 23:27:15 +00:00
|
|
|
/*
|
|
|
|
* If dm_wait_for_completion returned 0, the device is completely
|
|
|
|
* quiescent now. There is no request-processing activity. All new
|
|
|
|
* requests are being added to md->deferred list.
|
|
|
|
*/
|
|
|
|
|
2005-07-29 04:15:57 +00:00
|
|
|
dm_table_postsuspend_targets(map);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
set_bit(DMF_SUSPENDED, &md->flags);
|
2005-05-05 23:16:06 +00:00
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
out:
|
|
|
|
dm_table_put(map);
|
2006-11-09 01:44:43 +00:00
|
|
|
|
|
|
|
out_unlock:
|
2008-02-08 02:10:08 +00:00
|
|
|
mutex_unlock(&md->suspend_lock);
|
2005-07-29 04:15:57 +00:00
|
|
|
return r;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int dm_resume(struct mapped_device *md)
|
|
|
|
{
|
2005-07-29 04:15:57 +00:00
|
|
|
int r = -EINVAL;
|
|
|
|
struct dm_table *map = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 02:10:08 +00:00
|
|
|
mutex_lock(&md->suspend_lock);
|
2005-07-29 04:16:00 +00:00
|
|
|
if (!dm_suspended(md))
|
2005-07-29 04:15:57 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
map = dm_get_table(md);
|
2005-07-29 04:16:00 +00:00
|
|
|
if (!map || !dm_table_get_size(map))
|
2005-07-29 04:15:57 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-03 08:15:36 +00:00
|
|
|
r = dm_table_resume_targets(map);
|
|
|
|
if (r)
|
|
|
|
goto out;
|
2005-07-29 04:16:00 +00:00
|
|
|
|
2009-04-02 18:55:36 +00:00
|
|
|
dm_queue_flush(md);
|
2005-07-29 04:16:00 +00:00
|
|
|
|
dm: prepare for request based option
This patch adds core functions for request-based dm.
When struct mapped device (md) is initialized, md->queue has
an I/O scheduler and the following functions are used for
request-based dm as the queue functions:
make_request_fn: dm_make_request()
pref_fn: dm_prep_fn()
request_fn: dm_request_fn()
softirq_done_fn: dm_softirq_done()
lld_busy_fn: dm_lld_busy()
Actual initializations are done in another patch (PATCH 2).
Below is a brief summary of how request-based dm behaves, including:
- making request from bio
- cloning, mapping and dispatching request
- completing request and bio
- suspending md
- resuming md
bio to request
==============
md->queue->make_request_fn() (dm_make_request()) calls __make_request()
for a bio submitted to the md.
Then, the bio is kept in the queue as a new request or merged into
another request in the queue if possible.
Cloning and Mapping
===================
Cloning and mapping are done in md->queue->request_fn() (dm_request_fn()),
when requests are dispatched after they are sorted by the I/O scheduler.
dm_request_fn() checks busy state of underlying devices using
target's busy() function and stops dispatching requests to keep them
on the dm device's queue if busy.
It helps better I/O merging, since no merge is done for a request
once it is dispatched to underlying devices.
Actual cloning and mapping are done in dm_prep_fn() and map_request()
called from dm_request_fn().
dm_prep_fn() clones not only request but also bios of the request
so that dm can hold bio completion in error cases and prevent
the bio submitter from noticing the error.
(See the "Completion" section below for details.)
After the cloning, the clone is mapped by target's map_rq() function
and inserted to underlying device's queue using
blk_insert_cloned_request().
Completion
==========
Request completion can be hooked by rq->end_io(), but then, all bios
in the request will have been completed even error cases, and the bio
submitter will have noticed the error.
To prevent the bio completion in error cases, request-based dm clones
both bio and request and hooks both bio->bi_end_io() and rq->end_io():
bio->bi_end_io(): end_clone_bio()
rq->end_io(): end_clone_request()
Summary of the request completion flow is below:
blk_end_request() for a clone request
=> blk_update_request()
=> bio->bi_end_io() == end_clone_bio() for each clone bio
=> Free the clone bio
=> Success: Complete the original bio (blk_update_request())
Error: Don't complete the original bio
=> blk_finish_request()
=> rq->end_io() == end_clone_request()
=> blk_complete_request()
=> dm_softirq_done()
=> Free the clone request
=> Success: Complete the original request (blk_end_request())
Error: Requeue the original request
end_clone_bio() completes the original request on the size of
the original bio in successful cases.
Even if all bios in the original request are completed by that
completion, the original request must not be completed yet to keep
the ordering of request completion for the stacking.
So end_clone_bio() uses blk_update_request() instead of
blk_end_request().
In error cases, end_clone_bio() doesn't complete the original bio.
It just frees the cloned bio and gives over the error handling to
end_clone_request().
end_clone_request(), which is called with queue lock held, completes
the clone request and the original request in a softirq context
(dm_softirq_done()), which has no queue lock, to avoid a deadlock
issue on submission of another request during the completion:
- The submitted request may be mapped to the same device
- Request submission requires queue lock, but the queue lock
has been held by itself and it doesn't know that
The clone request has no clone bio when dm_softirq_done() is called.
So target drivers can't resubmit it again even error cases.
Instead, they can ask dm core for requeueing and remapping
the original request in that cases.
suspend
=======
Request-based dm uses stopping md->queue as suspend of the md.
For noflush suspend, just stops md->queue.
For flush suspend, inserts a marker request to the tail of md->queue.
And dispatches all requests in md->queue until the marker comes to
the front of md->queue. Then, stops dispatching request and waits
for the all dispatched requests to complete.
After that, completes the marker request, stops md->queue and
wake up the waiter on the suspend queue, md->wait.
resume
======
Starts md->queue.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:35 +00:00
|
|
|
/*
|
|
|
|
* Flushing deferred I/Os must be done after targets are resumed
|
|
|
|
* so that mapping of targets can work correctly.
|
|
|
|
* Request-based dm is queueing the deferred I/Os in its request_queue.
|
|
|
|
*/
|
|
|
|
if (dm_request_based(md))
|
|
|
|
start_queue(md->queue);
|
|
|
|
|
2005-07-29 04:16:00 +00:00
|
|
|
unlock_fs(md);
|
|
|
|
|
|
|
|
clear_bit(DMF_SUSPENDED, &md->flags);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
dm_table_unplug_all(map);
|
2005-07-29 04:15:57 +00:00
|
|
|
r = 0;
|
|
|
|
out:
|
|
|
|
dm_table_put(map);
|
2008-02-08 02:10:08 +00:00
|
|
|
mutex_unlock(&md->suspend_lock);
|
2005-07-29 04:16:00 +00:00
|
|
|
|
2005-07-29 04:15:57 +00:00
|
|
|
return r;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------
|
|
|
|
* Event notification.
|
|
|
|
*---------------------------------------------------------------*/
|
2009-06-22 09:12:30 +00:00
|
|
|
void dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
|
|
|
|
unsigned cookie)
|
2007-12-13 14:15:57 +00:00
|
|
|
{
|
2009-06-22 09:12:30 +00:00
|
|
|
char udev_cookie[DM_COOKIE_LENGTH];
|
|
|
|
char *envp[] = { udev_cookie, NULL };
|
|
|
|
|
|
|
|
if (!cookie)
|
|
|
|
kobject_uevent(&disk_to_dev(md->disk)->kobj, action);
|
|
|
|
else {
|
|
|
|
snprintf(udev_cookie, DM_COOKIE_LENGTH, "%s=%u",
|
|
|
|
DM_COOKIE_ENV_VAR_NAME, cookie);
|
|
|
|
kobject_uevent_env(&disk_to_dev(md->disk)->kobj, action, envp);
|
|
|
|
}
|
2007-12-13 14:15:57 +00:00
|
|
|
}
|
|
|
|
|
2007-10-19 21:48:01 +00:00
|
|
|
uint32_t dm_next_uevent_seq(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return atomic_add_return(1, &md->uevent_seq);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
uint32_t dm_get_event_nr(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return atomic_read(&md->event_nr);
|
|
|
|
}
|
|
|
|
|
|
|
|
int dm_wait_event(struct mapped_device *md, int event_nr)
|
|
|
|
{
|
|
|
|
return wait_event_interruptible(md->eventq,
|
|
|
|
(event_nr != atomic_read(&md->event_nr)));
|
|
|
|
}
|
|
|
|
|
2007-10-19 21:48:01 +00:00
|
|
|
void dm_uevent_add(struct mapped_device *md, struct list_head *elist)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&md->uevent_lock, flags);
|
|
|
|
list_add(elist, &md->uevent_list);
|
|
|
|
spin_unlock_irqrestore(&md->uevent_lock, flags);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The gendisk is only valid as long as you have a reference
|
|
|
|
* count on 'md'.
|
|
|
|
*/
|
|
|
|
struct gendisk *dm_disk(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return md->disk;
|
|
|
|
}
|
|
|
|
|
2009-01-06 03:05:12 +00:00
|
|
|
struct kobject *dm_kobject(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return &md->kobj;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* struct mapped_device should not be exported outside of dm.c
|
|
|
|
* so use this check to verify that kobj is part of md structure
|
|
|
|
*/
|
|
|
|
struct mapped_device *dm_get_from_kobject(struct kobject *kobj)
|
|
|
|
{
|
|
|
|
struct mapped_device *md;
|
|
|
|
|
|
|
|
md = container_of(kobj, struct mapped_device, kobj);
|
|
|
|
if (&md->kobj != kobj)
|
|
|
|
return NULL;
|
|
|
|
|
2009-06-22 09:12:11 +00:00
|
|
|
if (test_bit(DMF_FREEING, &md->flags) ||
|
|
|
|
test_bit(DMF_DELETING, &md->flags))
|
|
|
|
return NULL;
|
|
|
|
|
2009-01-06 03:05:12 +00:00
|
|
|
dm_get(md);
|
|
|
|
return md;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int dm_suspended(struct mapped_device *md)
|
|
|
|
{
|
|
|
|
return test_bit(DMF_SUSPENDED, &md->flags);
|
|
|
|
}
|
|
|
|
|
[PATCH] dm: suspend: add noflush pushback
In device-mapper I/O is sometimes queued within targets for later processing.
For example the multipath target can be configured to store I/O when no paths
are available instead of returning it -EIO.
This patch allows the device-mapper core to instruct a target to transfer the
contents of any such in-target queue back into the core. This frees up the
resources used by the target so the core can replace that target with an
alternative one and then resend the I/O to it. Without this patch the only
way to change the target in such circumstances involves returning the I/O with
an error back to the filesystem/application. In the multipath case, this
patch will let us add new paths for existing I/O to try after all the existing
paths have failed.
DMF_NOFLUSH_SUSPENDING
----------------------
If the DM_NOFLUSH_FLAG ioctl option is specified at suspend time, the
DMF_NOFLUSH_SUSPENDING flag is set in md->flags during dm_suspend(). It
is always cleared before dm_suspend() returns.
The flag must be visible while the target is flushing pending I/Os so it
is set before presuspend where the flush starts and unset after the wait
for md->pending where the flush ends.
Target drivers can check this flag by calling dm_noflush_suspending().
DM_MAPIO_REQUEUE / DM_ENDIO_REQUEUE
-----------------------------------
A target's map() function can now return DM_MAPIO_REQUEUE to request the
device mapper core queue the bio.
Similarly, a target's end_io() function can return DM_ENDIO_REQUEUE to request
the same. This has been labelled 'pushback'.
The __map_bio() and clone_endio() functions in the core treat these return
values as errors and call dec_pending() to end the I/O.
dec_pending
-----------
dec_pending() saves the pushback request in struct dm_io->error. Once all
the split clones have ended, dec_pending() will put the original bio on
the md->pushback list. Note that this supercedes any I/O errors.
It is possible for the suspend with DM_NOFLUSH_FLAG to be aborted while
in progress (e.g. by user interrupt). dec_pending() checks for this and
returns -EIO if it happened.
pushdback list and pushback_lock
--------------------------------
The bio is queued on md->pushback temporarily in dec_pending(), and after
all pending I/Os return, md->pushback is merged into md->deferred in
dm_suspend() for re-issuing at resume time.
md->pushback_lock protects md->pushback.
The lock should be held with irq disabled because dec_pending() can be
called from interrupt context.
Queueing bios to md->pushback in dec_pending() must be done atomically
with the check for DMF_NOFLUSH_SUSPENDING flag. So md->pushback_lock is
held when checking the flag. Otherwise dec_pending() may queue a bio to
md->pushback after the interrupted dm_suspend() flushes md->pushback.
Then the bio would be left in md->pushback.
Flag setting in dm_suspend() can be done without md->pushback_lock because
the flag is checked only after presuspend and the set value is already
made visible via the target's presuspend function.
The flag can be checked without md->pushback_lock (e.g. the first part of
the dec_pending() or target drivers), because the flag is checked again
with md->pushback_lock held when the bio is really queued to md->pushback
as described above. So even if the flag is cleared after the lockless
checkings, the bio isn't left in md->pushback but returned to applications
with -EIO.
Other notes on the current patch
--------------------------------
- md->pushback is added to the struct mapped_device instead of using
md->deferred directly because md->io_lock which protects md->deferred is
rw_semaphore and can't be used in interrupt context like dec_pending(),
and md->io_lock protects the DMF_BLOCK_IO flag of md->flags too.
- Don't issue lock_fs() in dm_suspend() if the DM_NOFLUSH_FLAG
ioctl option is specified, because I/Os generated by lock_fs() would be
pushed back and never return if there were no valid devices.
- If an error occurs in dm_suspend() after the DMF_NOFLUSH_SUSPENDING
flag is set, md->pushback must be flushed because I/Os may be queued to
the list already. (flush_and_out label in dm_suspend())
Test results
------------
I have tested using multipath target with the next patch.
The following tests are for regression/compatibility:
- I/Os succeed when valid paths exist;
- I/Os fail when there are no valid paths and queue_if_no_path is not
set;
- I/Os are queued in the multipath target when there are no valid paths and
queue_if_no_path is set;
- The queued I/Os above fail when suspend is issued without the
DM_NOFLUSH_FLAG ioctl option. I/Os spanning 2 multipath targets also
fail.
The following tests are for the normal code path of new pushback feature:
- Queued I/Os in the multipath target are flushed from the target
but don't return when suspend is issued with the DM_NOFLUSH_FLAG
ioctl option;
- The I/Os above are queued in the multipath target again when
resume is issued without path recovery;
- The I/Os above succeed when resume is issued after path recovery
or table load;
- Queued I/Os in the multipath target succeed when resume is issued
with the DM_NOFLUSH_FLAG ioctl option after table load. I/Os
spanning 2 multipath targets also succeed.
The following tests are for the error paths of the new pushback feature:
- When the bdget_disk() fails in dm_suspend(), the
DMF_NOFLUSH_SUSPENDING flag is cleared and I/Os already queued to the
pushback list are flushed properly.
- When suspend with the DM_NOFLUSH_FLAG ioctl option is interrupted,
o I/Os which had already been queued to the pushback list
at the time don't return, and are re-issued at resume time;
o I/Os which hadn't been returned at the time return with EIO.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
Cc: dm-devel@redhat.com
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:41:09 +00:00
|
|
|
int dm_noflush_suspending(struct dm_target *ti)
|
|
|
|
{
|
|
|
|
struct mapped_device *md = dm_table_get_md(ti->table);
|
|
|
|
int r = __noflush_suspending(md);
|
|
|
|
|
|
|
|
dm_put(md);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(dm_noflush_suspending);
|
|
|
|
|
dm: enable request based option
This patch enables request-based dm.
o Request-based dm and bio-based dm coexist, since there are
some target drivers which are more fitting to bio-based dm.
Also, there are other bio-based devices in the kernel
(e.g. md, loop).
Since bio-based device can't receive struct request,
there are some limitations on device stacking between
bio-based and request-based.
type of underlying device
bio-based request-based
----------------------------------------------
bio-based OK OK
request-based -- OK
The device type is recognized by the queue flag in the kernel,
so dm follows that.
o The type of a dm device is decided at the first table binding time.
Once the type of a dm device is decided, the type can't be changed.
o Mempool allocations are deferred to at the table loading time, since
mempools for request-based dm are different from those for bio-based
dm and needed mempool type is fixed by the type of table.
o Currently, request-based dm supports only tables that have a single
target. To support multiple targets, we need to support request
splitting or prevent bio/request from spanning multiple targets.
The former needs lots of changes in the block layer, and the latter
needs that all target drivers support merge() function.
Both will take a time.
Signed-off-by: Kiyoshi Ueda <k-ueda@ct.jp.nec.com>
Signed-off-by: Jun'ichi Nomura <j-nomura@ce.jp.nec.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>
2009-06-22 09:12:36 +00:00
|
|
|
struct dm_md_mempools *dm_alloc_md_mempools(unsigned type)
|
|
|
|
{
|
|
|
|
struct dm_md_mempools *pools = kmalloc(sizeof(*pools), GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!pools)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pools->io_pool = (type == DM_TYPE_BIO_BASED) ?
|
|
|
|
mempool_create_slab_pool(MIN_IOS, _io_cache) :
|
|
|
|
mempool_create_slab_pool(MIN_IOS, _rq_bio_info_cache);
|
|
|
|
if (!pools->io_pool)
|
|
|
|
goto free_pools_and_out;
|
|
|
|
|
|
|
|
pools->tio_pool = (type == DM_TYPE_BIO_BASED) ?
|
|
|
|
mempool_create_slab_pool(MIN_IOS, _tio_cache) :
|
|
|
|
mempool_create_slab_pool(MIN_IOS, _rq_tio_cache);
|
|
|
|
if (!pools->tio_pool)
|
|
|
|
goto free_io_pool_and_out;
|
|
|
|
|
|
|
|
pools->bs = (type == DM_TYPE_BIO_BASED) ?
|
|
|
|
bioset_create(16, 0) : bioset_create(MIN_IOS, 0);
|
|
|
|
if (!pools->bs)
|
|
|
|
goto free_tio_pool_and_out;
|
|
|
|
|
|
|
|
return pools;
|
|
|
|
|
|
|
|
free_tio_pool_and_out:
|
|
|
|
mempool_destroy(pools->tio_pool);
|
|
|
|
|
|
|
|
free_io_pool_and_out:
|
|
|
|
mempool_destroy(pools->io_pool);
|
|
|
|
|
|
|
|
free_pools_and_out:
|
|
|
|
kfree(pools);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void dm_free_md_mempools(struct dm_md_mempools *pools)
|
|
|
|
{
|
|
|
|
if (!pools)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (pools->io_pool)
|
|
|
|
mempool_destroy(pools->io_pool);
|
|
|
|
|
|
|
|
if (pools->tio_pool)
|
|
|
|
mempool_destroy(pools->tio_pool);
|
|
|
|
|
|
|
|
if (pools->bs)
|
|
|
|
bioset_free(pools->bs);
|
|
|
|
|
|
|
|
kfree(pools);
|
|
|
|
}
|
|
|
|
|
2009-09-22 00:01:13 +00:00
|
|
|
static const struct block_device_operations dm_blk_dops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.open = dm_blk_open,
|
|
|
|
.release = dm_blk_close,
|
2006-10-03 08:15:15 +00:00
|
|
|
.ioctl = dm_blk_ioctl,
|
2006-03-27 09:17:54 +00:00
|
|
|
.getgeo = dm_blk_getgeo,
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE
|
|
|
|
};
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(dm_get_mapinfo);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* module hooks
|
|
|
|
*/
|
|
|
|
module_init(dm_init);
|
|
|
|
module_exit(dm_exit);
|
|
|
|
|
|
|
|
module_param(major, uint, 0);
|
|
|
|
MODULE_PARM_DESC(major, "The major number of the device mapper");
|
|
|
|
MODULE_DESCRIPTION(DM_NAME " driver");
|
|
|
|
MODULE_AUTHOR("Joe Thornber <dm-devel@redhat.com>");
|
|
|
|
MODULE_LICENSE("GPL");
|