mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-29 11:11:45 -04:00
Merge branch 'for-2.6.39/stack-plug' into for-2.6.39/core
Conflicts: block/blk-core.c block/blk-flush.c drivers/md/raid1.c drivers/md/raid10.c drivers/md/raid5.c fs/nilfs2/btnode.c fs/nilfs2/mdt.c Signed-off-by: Jens Axboe <[email protected]>
This commit is contained in:
Jens Axboe
commit
4c63f5646e
137 changed files with 606 additions and 1533 deletions
|
|
@ -347,7 +347,7 @@ static void write_page(struct bitmap *bitmap, struct page *page, int wait)
|
|||
atomic_inc(&bitmap->pending_writes);
|
||||
set_buffer_locked(bh);
|
||||
set_buffer_mapped(bh);
|
||||
submit_bh(WRITE | REQ_UNPLUG | REQ_SYNC, bh);
|
||||
submit_bh(WRITE | REQ_SYNC, bh);
|
||||
bh = bh->b_this_page;
|
||||
}
|
||||
|
||||
|
|
@ -1339,8 +1339,7 @@ int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sect
|
|||
prepare_to_wait(&bitmap->overflow_wait, &__wait,
|
||||
TASK_UNINTERRUPTIBLE);
|
||||
spin_unlock_irq(&bitmap->lock);
|
||||
md_unplug(bitmap->mddev);
|
||||
schedule();
|
||||
io_schedule();
|
||||
finish_wait(&bitmap->overflow_wait, &__wait);
|
||||
continue;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -991,11 +991,6 @@ static void clone_init(struct dm_crypt_io *io, struct bio *clone)
|
|||
clone->bi_destructor = dm_crypt_bio_destructor;
|
||||
}
|
||||
|
||||
static void kcryptd_unplug(struct crypt_config *cc)
|
||||
{
|
||||
blk_unplug(bdev_get_queue(cc->dev->bdev));
|
||||
}
|
||||
|
||||
static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
|
||||
{
|
||||
struct crypt_config *cc = io->target->private;
|
||||
|
|
@ -1008,10 +1003,8 @@ static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
|
|||
* one in order to decrypt the whole bio data *afterwards*.
|
||||
*/
|
||||
clone = bio_alloc_bioset(gfp, bio_segments(base_bio), cc->bs);
|
||||
if (!clone) {
|
||||
kcryptd_unplug(cc);
|
||||
if (!clone)
|
||||
return 1;
|
||||
}
|
||||
|
||||
crypt_inc_pending(io);
|
||||
|
||||
|
|
|
|||
|
|
@ -352,7 +352,7 @@ static void dispatch_io(int rw, unsigned int num_regions,
|
|||
BUG_ON(num_regions > DM_IO_MAX_REGIONS);
|
||||
|
||||
if (sync)
|
||||
rw |= REQ_SYNC | REQ_UNPLUG;
|
||||
rw |= REQ_SYNC;
|
||||
|
||||
/*
|
||||
* For multiple regions we need to be careful to rewind
|
||||
|
|
|
|||
|
|
@ -37,13 +37,6 @@ struct dm_kcopyd_client {
|
|||
unsigned int nr_pages;
|
||||
unsigned int nr_free_pages;
|
||||
|
||||
/*
|
||||
* Block devices to unplug.
|
||||
* Non-NULL pointer means that a block device has some pending requests
|
||||
* and needs to be unplugged.
|
||||
*/
|
||||
struct block_device *unplug[2];
|
||||
|
||||
struct dm_io_client *io_client;
|
||||
|
||||
wait_queue_head_t destroyq;
|
||||
|
|
@ -315,31 +308,6 @@ static int run_complete_job(struct kcopyd_job *job)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Unplug the block device at the specified index.
|
||||
*/
|
||||
static void unplug(struct dm_kcopyd_client *kc, int rw)
|
||||
{
|
||||
if (kc->unplug[rw] != NULL) {
|
||||
blk_unplug(bdev_get_queue(kc->unplug[rw]));
|
||||
kc->unplug[rw] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Prepare block device unplug. If there's another device
|
||||
* to be unplugged at the same array index, we unplug that
|
||||
* device first.
|
||||
*/
|
||||
static void prepare_unplug(struct dm_kcopyd_client *kc, int rw,
|
||||
struct block_device *bdev)
|
||||
{
|
||||
if (likely(kc->unplug[rw] == bdev))
|
||||
return;
|
||||
unplug(kc, rw);
|
||||
kc->unplug[rw] = bdev;
|
||||
}
|
||||
|
||||
static void complete_io(unsigned long error, void *context)
|
||||
{
|
||||
struct kcopyd_job *job = (struct kcopyd_job *) context;
|
||||
|
|
@ -386,16 +354,10 @@ static int run_io_job(struct kcopyd_job *job)
|
|||
.client = job->kc->io_client,
|
||||
};
|
||||
|
||||
if (job->rw == READ) {
|
||||
if (job->rw == READ)
|
||||
r = dm_io(&io_req, 1, &job->source, NULL);
|
||||
prepare_unplug(job->kc, READ, job->source.bdev);
|
||||
} else {
|
||||
if (job->num_dests > 1)
|
||||
io_req.bi_rw |= REQ_UNPLUG;
|
||||
else
|
||||
r = dm_io(&io_req, job->num_dests, job->dests, NULL);
|
||||
if (!(io_req.bi_rw & REQ_UNPLUG))
|
||||
prepare_unplug(job->kc, WRITE, job->dests[0].bdev);
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
|
@ -466,6 +428,7 @@ static void do_work(struct work_struct *work)
|
|||
{
|
||||
struct dm_kcopyd_client *kc = container_of(work,
|
||||
struct dm_kcopyd_client, kcopyd_work);
|
||||
struct blk_plug plug;
|
||||
|
||||
/*
|
||||
* The order that these are called is *very* important.
|
||||
|
|
@ -473,18 +436,12 @@ static void do_work(struct work_struct *work)
|
|||
* Pages jobs when successful will jump onto the io jobs
|
||||
* list. io jobs call wake when they complete and it all
|
||||
* starts again.
|
||||
*
|
||||
* Note that io_jobs add block devices to the unplug array,
|
||||
* this array is cleared with "unplug" calls. It is thus
|
||||
* forbidden to run complete_jobs after io_jobs and before
|
||||
* unplug because the block device could be destroyed in
|
||||
* job completion callback.
|
||||
*/
|
||||
blk_start_plug(&plug);
|
||||
process_jobs(&kc->complete_jobs, kc, run_complete_job);
|
||||
process_jobs(&kc->pages_jobs, kc, run_pages_job);
|
||||
process_jobs(&kc->io_jobs, kc, run_io_job);
|
||||
unplug(kc, READ);
|
||||
unplug(kc, WRITE);
|
||||
blk_finish_plug(&plug);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -665,8 +622,6 @@ int dm_kcopyd_client_create(unsigned int nr_pages,
|
|||
INIT_LIST_HEAD(&kc->io_jobs);
|
||||
INIT_LIST_HEAD(&kc->pages_jobs);
|
||||
|
||||
memset(kc->unplug, 0, sizeof(kc->unplug));
|
||||
|
||||
kc->job_pool = mempool_create_slab_pool(MIN_JOBS, _job_cache);
|
||||
if (!kc->job_pool)
|
||||
goto bad_slab;
|
||||
|
|
|
|||
|
|
@ -394,7 +394,7 @@ static void raid_unplug(struct dm_target_callbacks *cb)
|
|||
{
|
||||
struct raid_set *rs = container_of(cb, struct raid_set, callbacks);
|
||||
|
||||
md_raid5_unplug_device(rs->md.private);
|
||||
md_raid5_kick_device(rs->md.private);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -842,8 +842,6 @@ static void do_mirror(struct work_struct *work)
|
|||
do_reads(ms, &reads);
|
||||
do_writes(ms, &writes);
|
||||
do_failures(ms, &failures);
|
||||
|
||||
dm_table_unplug_all(ms->ti->table);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -1275,29 +1275,6 @@ int dm_table_any_busy_target(struct dm_table *t)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void dm_table_unplug_all(struct dm_table *t)
|
||||
{
|
||||
struct dm_dev_internal *dd;
|
||||
struct list_head *devices = dm_table_get_devices(t);
|
||||
struct dm_target_callbacks *cb;
|
||||
|
||||
list_for_each_entry(dd, devices, list) {
|
||||
struct request_queue *q = bdev_get_queue(dd->dm_dev.bdev);
|
||||
char b[BDEVNAME_SIZE];
|
||||
|
||||
if (likely(q))
|
||||
blk_unplug(q);
|
||||
else
|
||||
DMWARN_LIMIT("%s: Cannot unplug nonexistent device %s",
|
||||
dm_device_name(t->md),
|
||||
bdevname(dd->dm_dev.bdev, b));
|
||||
}
|
||||
|
||||
list_for_each_entry(cb, &t->target_callbacks, list)
|
||||
if (cb->unplug_fn)
|
||||
cb->unplug_fn(cb);
|
||||
}
|
||||
|
||||
struct mapped_device *dm_table_get_md(struct dm_table *t)
|
||||
{
|
||||
return t->md;
|
||||
|
|
@ -1345,4 +1322,3 @@ EXPORT_SYMBOL(dm_table_get_mode);
|
|||
EXPORT_SYMBOL(dm_table_get_md);
|
||||
EXPORT_SYMBOL(dm_table_put);
|
||||
EXPORT_SYMBOL(dm_table_get);
|
||||
EXPORT_SYMBOL(dm_table_unplug_all);
|
||||
|
|
|
|||
|
|
@ -807,8 +807,6 @@ void dm_requeue_unmapped_request(struct request *clone)
|
|||
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);
|
||||
|
||||
|
|
@ -1613,10 +1611,10 @@ static void dm_request_fn(struct request_queue *q)
|
|||
* number of in-flight I/Os after the queue is stopped in
|
||||
* dm_suspend().
|
||||
*/
|
||||
while (!blk_queue_plugged(q) && !blk_queue_stopped(q)) {
|
||||
while (!blk_queue_stopped(q)) {
|
||||
rq = blk_peek_request(q);
|
||||
if (!rq)
|
||||
goto plug_and_out;
|
||||
goto delay_and_out;
|
||||
|
||||
/* always use block 0 to find the target for flushes for now */
|
||||
pos = 0;
|
||||
|
|
@ -1627,7 +1625,7 @@ static void dm_request_fn(struct request_queue *q)
|
|||
BUG_ON(!dm_target_is_valid(ti));
|
||||
|
||||
if (ti->type->busy && ti->type->busy(ti))
|
||||
goto plug_and_out;
|
||||
goto delay_and_out;
|
||||
|
||||
blk_start_request(rq);
|
||||
clone = rq->special;
|
||||
|
|
@ -1647,11 +1645,8 @@ requeued:
|
|||
BUG_ON(!irqs_disabled());
|
||||
spin_lock(q->queue_lock);
|
||||
|
||||
plug_and_out:
|
||||
if (!elv_queue_empty(q))
|
||||
/* Some requests still remain, retry later */
|
||||
blk_plug_device(q);
|
||||
|
||||
delay_and_out:
|
||||
blk_delay_queue(q, HZ / 10);
|
||||
out:
|
||||
dm_table_put(map);
|
||||
|
||||
|
|
@ -1680,20 +1675,6 @@ static int dm_lld_busy(struct request_queue *q)
|
|||
return r;
|
||||
}
|
||||
|
||||
static void dm_unplug_all(struct request_queue *q)
|
||||
{
|
||||
struct mapped_device *md = q->queuedata;
|
||||
struct dm_table *map = dm_get_live_table(md);
|
||||
|
||||
if (map) {
|
||||
if (dm_request_based(md))
|
||||
generic_unplug_device(q);
|
||||
|
||||
dm_table_unplug_all(map);
|
||||
dm_table_put(map);
|
||||
}
|
||||
}
|
||||
|
||||
static int dm_any_congested(void *congested_data, int bdi_bits)
|
||||
{
|
||||
int r = bdi_bits;
|
||||
|
|
@ -1817,7 +1798,6 @@ static void dm_init_md_queue(struct mapped_device *md)
|
|||
md->queue->backing_dev_info.congested_data = md;
|
||||
blk_queue_make_request(md->queue, dm_request);
|
||||
blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
|
||||
md->queue->unplug_fn = dm_unplug_all;
|
||||
blk_queue_merge_bvec(md->queue, dm_merge_bvec);
|
||||
blk_queue_flush(md->queue, REQ_FLUSH | REQ_FUA);
|
||||
}
|
||||
|
|
@ -2263,8 +2243,6 @@ static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
|
|||
int r = 0;
|
||||
DECLARE_WAITQUEUE(wait, current);
|
||||
|
||||
dm_unplug_all(md->queue);
|
||||
|
||||
add_wait_queue(&md->wait, &wait);
|
||||
|
||||
while (1) {
|
||||
|
|
@ -2539,7 +2517,6 @@ int dm_resume(struct mapped_device *md)
|
|||
|
||||
clear_bit(DMF_SUSPENDED, &md->flags);
|
||||
|
||||
dm_table_unplug_all(map);
|
||||
r = 0;
|
||||
out:
|
||||
dm_table_put(map);
|
||||
|
|
|
|||
|
|
@ -87,22 +87,6 @@ static int linear_mergeable_bvec(struct request_queue *q,
|
|||
return maxsectors << 9;
|
||||
}
|
||||
|
||||
static void linear_unplug(struct request_queue *q)
|
||||
{
|
||||
mddev_t *mddev = q->queuedata;
|
||||
linear_conf_t *conf;
|
||||
int i;
|
||||
|
||||
rcu_read_lock();
|
||||
conf = rcu_dereference(mddev->private);
|
||||
|
||||
for (i=0; i < mddev->raid_disks; i++) {
|
||||
struct request_queue *r_queue = bdev_get_queue(conf->disks[i].rdev->bdev);
|
||||
blk_unplug(r_queue);
|
||||
}
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
static int linear_congested(void *data, int bits)
|
||||
{
|
||||
mddev_t *mddev = data;
|
||||
|
|
@ -224,7 +208,6 @@ static int linear_run (mddev_t *mddev)
|
|||
md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
|
||||
|
||||
blk_queue_merge_bvec(mddev->queue, linear_mergeable_bvec);
|
||||
mddev->queue->unplug_fn = linear_unplug;
|
||||
mddev->queue->backing_dev_info.congested_fn = linear_congested;
|
||||
mddev->queue->backing_dev_info.congested_data = mddev;
|
||||
md_integrity_register(mddev);
|
||||
|
|
|
|||
|
|
@ -780,8 +780,7 @@ void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
|
|||
bio->bi_end_io = super_written;
|
||||
|
||||
atomic_inc(&mddev->pending_writes);
|
||||
submit_bio(REQ_WRITE | REQ_SYNC | REQ_UNPLUG | REQ_FLUSH | REQ_FUA,
|
||||
bio);
|
||||
submit_bio(REQ_WRITE | REQ_SYNC | REQ_FLUSH | REQ_FUA, bio);
|
||||
}
|
||||
|
||||
void md_super_wait(mddev_t *mddev)
|
||||
|
|
@ -809,7 +808,7 @@ int sync_page_io(mdk_rdev_t *rdev, sector_t sector, int size,
|
|||
struct completion event;
|
||||
int ret;
|
||||
|
||||
rw |= REQ_SYNC | REQ_UNPLUG;
|
||||
rw |= REQ_SYNC;
|
||||
|
||||
bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
|
||||
rdev->meta_bdev : rdev->bdev;
|
||||
|
|
@ -4817,7 +4816,6 @@ static int do_md_stop(mddev_t * mddev, int mode, int is_open)
|
|||
__md_stop_writes(mddev);
|
||||
md_stop(mddev);
|
||||
mddev->queue->merge_bvec_fn = NULL;
|
||||
mddev->queue->unplug_fn = NULL;
|
||||
mddev->queue->backing_dev_info.congested_fn = NULL;
|
||||
|
||||
/* tell userspace to handle 'inactive' */
|
||||
|
|
@ -6692,8 +6690,6 @@ EXPORT_SYMBOL_GPL(md_allow_write);
|
|||
|
||||
void md_unplug(mddev_t *mddev)
|
||||
{
|
||||
if (mddev->queue)
|
||||
blk_unplug(mddev->queue);
|
||||
if (mddev->plug)
|
||||
mddev->plug->unplug_fn(mddev->plug);
|
||||
}
|
||||
|
|
@ -6876,7 +6872,6 @@ void md_do_sync(mddev_t *mddev)
|
|||
>= mddev->resync_max - mddev->curr_resync_completed
|
||||
)) {
|
||||
/* time to update curr_resync_completed */
|
||||
md_unplug(mddev);
|
||||
wait_event(mddev->recovery_wait,
|
||||
atomic_read(&mddev->recovery_active) == 0);
|
||||
mddev->curr_resync_completed = j;
|
||||
|
|
@ -6952,7 +6947,6 @@ void md_do_sync(mddev_t *mddev)
|
|||
* about not overloading the IO subsystem. (things like an
|
||||
* e2fsck being done on the RAID array should execute fast)
|
||||
*/
|
||||
md_unplug(mddev);
|
||||
cond_resched();
|
||||
|
||||
currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
|
||||
|
|
@ -6971,8 +6965,6 @@ void md_do_sync(mddev_t *mddev)
|
|||
* this also signals 'finished resyncing' to md_stop
|
||||
*/
|
||||
out:
|
||||
md_unplug(mddev);
|
||||
|
||||
wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
|
||||
|
||||
/* tell personality that we are finished */
|
||||
|
|
|
|||
|
|
@ -106,36 +106,6 @@ static void multipath_end_request(struct bio *bio, int error)
|
|||
rdev_dec_pending(rdev, conf->mddev);
|
||||
}
|
||||
|
||||
static void unplug_slaves(mddev_t *mddev)
|
||||
{
|
||||
multipath_conf_t *conf = mddev->private;
|
||||
int i;
|
||||
|
||||
rcu_read_lock();
|
||||
for (i=0; i<mddev->raid_disks; i++) {
|
||||
mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
|
||||
if (rdev && !test_bit(Faulty, &rdev->flags)
|
||||
&& atomic_read(&rdev->nr_pending)) {
|
||||
struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
|
||||
|
||||
atomic_inc(&rdev->nr_pending);
|
||||
rcu_read_unlock();
|
||||
|
||||
blk_unplug(r_queue);
|
||||
|
||||
rdev_dec_pending(rdev, mddev);
|
||||
rcu_read_lock();
|
||||
}
|
||||
}
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
static void multipath_unplug(struct request_queue *q)
|
||||
{
|
||||
unplug_slaves(q->queuedata);
|
||||
}
|
||||
|
||||
|
||||
static int multipath_make_request(mddev_t *mddev, struct bio * bio)
|
||||
{
|
||||
multipath_conf_t *conf = mddev->private;
|
||||
|
|
@ -517,7 +487,6 @@ static int multipath_run (mddev_t *mddev)
|
|||
*/
|
||||
md_set_array_sectors(mddev, multipath_size(mddev, 0, 0));
|
||||
|
||||
mddev->queue->unplug_fn = multipath_unplug;
|
||||
mddev->queue->backing_dev_info.congested_fn = multipath_congested;
|
||||
mddev->queue->backing_dev_info.congested_data = mddev;
|
||||
md_integrity_register(mddev);
|
||||
|
|
|
|||
|
|
@ -25,21 +25,6 @@
|
|||
#include "raid0.h"
|
||||
#include "raid5.h"
|
||||
|
||||
static void raid0_unplug(struct request_queue *q)
|
||||
{
|
||||
mddev_t *mddev = q->queuedata;
|
||||
raid0_conf_t *conf = mddev->private;
|
||||
mdk_rdev_t **devlist = conf->devlist;
|
||||
int raid_disks = conf->strip_zone[0].nb_dev;
|
||||
int i;
|
||||
|
||||
for (i=0; i < raid_disks; i++) {
|
||||
struct request_queue *r_queue = bdev_get_queue(devlist[i]->bdev);
|
||||
|
||||
blk_unplug(r_queue);
|
||||
}
|
||||
}
|
||||
|
||||
static int raid0_congested(void *data, int bits)
|
||||
{
|
||||
mddev_t *mddev = data;
|
||||
|
|
@ -272,7 +257,6 @@ static int create_strip_zones(mddev_t *mddev, raid0_conf_t **private_conf)
|
|||
mdname(mddev),
|
||||
(unsigned long long)smallest->sectors);
|
||||
}
|
||||
mddev->queue->unplug_fn = raid0_unplug;
|
||||
mddev->queue->backing_dev_info.congested_fn = raid0_congested;
|
||||
mddev->queue->backing_dev_info.congested_data = mddev;
|
||||
|
||||
|
|
|
|||
|
|
@ -52,23 +52,16 @@
|
|||
#define NR_RAID1_BIOS 256
|
||||
|
||||
|
||||
static void unplug_slaves(mddev_t *mddev);
|
||||
|
||||
static void allow_barrier(conf_t *conf);
|
||||
static void lower_barrier(conf_t *conf);
|
||||
|
||||
static void * r1bio_pool_alloc(gfp_t gfp_flags, void *data)
|
||||
{
|
||||
struct pool_info *pi = data;
|
||||
r1bio_t *r1_bio;
|
||||
int size = offsetof(r1bio_t, bios[pi->raid_disks]);
|
||||
|
||||
/* allocate a r1bio with room for raid_disks entries in the bios array */
|
||||
r1_bio = kzalloc(size, gfp_flags);
|
||||
if (!r1_bio && pi->mddev)
|
||||
unplug_slaves(pi->mddev);
|
||||
|
||||
return r1_bio;
|
||||
return kzalloc(size, gfp_flags);
|
||||
}
|
||||
|
||||
static void r1bio_pool_free(void *r1_bio, void *data)
|
||||
|
|
@ -91,10 +84,8 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
|
|||
int i, j;
|
||||
|
||||
r1_bio = r1bio_pool_alloc(gfp_flags, pi);
|
||||
if (!r1_bio) {
|
||||
unplug_slaves(pi->mddev);
|
||||
if (!r1_bio)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocate bios : 1 for reading, n-1 for writing
|
||||
|
|
@ -520,37 +511,6 @@ static int read_balance(conf_t *conf, r1bio_t *r1_bio)
|
|||
return new_disk;
|
||||
}
|
||||
|
||||
static void unplug_slaves(mddev_t *mddev)
|
||||
{
|
||||
conf_t *conf = mddev->private;
|
||||
int i;
|
||||
|
||||
rcu_read_lock();
|
||||
for (i=0; i<mddev->raid_disks; i++) {
|
||||
mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
|
||||
if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
|
||||
struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
|
||||
|
||||
atomic_inc(&rdev->nr_pending);
|
||||
rcu_read_unlock();
|
||||
|
||||
blk_unplug(r_queue);
|
||||
|
||||
rdev_dec_pending(rdev, mddev);
|
||||
rcu_read_lock();
|
||||
}
|
||||
}
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
static void raid1_unplug(struct request_queue *q)
|
||||
{
|
||||
mddev_t *mddev = q->queuedata;
|
||||
|
||||
unplug_slaves(mddev);
|
||||
md_wakeup_thread(mddev->thread);
|
||||
}
|
||||
|
||||
static int raid1_congested(void *data, int bits)
|
||||
{
|
||||
mddev_t *mddev = data;
|
||||
|
|
@ -580,23 +540,16 @@ static int raid1_congested(void *data, int bits)
|
|||
}
|
||||
|
||||
|
||||
static int flush_pending_writes(conf_t *conf)
|
||||
static void flush_pending_writes(conf_t *conf)
|
||||
{
|
||||
/* Any writes that have been queued but are awaiting
|
||||
* bitmap updates get flushed here.
|
||||
* We return 1 if any requests were actually submitted.
|
||||
*/
|
||||
int rv = 0;
|
||||
|
||||
spin_lock_irq(&conf->device_lock);
|
||||
|
||||
if (conf->pending_bio_list.head) {
|
||||
struct bio *bio;
|
||||
bio = bio_list_get(&conf->pending_bio_list);
|
||||
/* Only take the spinlock to quiet a warning */
|
||||
spin_lock(conf->mddev->queue->queue_lock);
|
||||
blk_remove_plug(conf->mddev->queue);
|
||||
spin_unlock(conf->mddev->queue->queue_lock);
|
||||
spin_unlock_irq(&conf->device_lock);
|
||||
/* flush any pending bitmap writes to
|
||||
* disk before proceeding w/ I/O */
|
||||
|
|
@ -608,10 +561,14 @@ static int flush_pending_writes(conf_t *conf)
|
|||
generic_make_request(bio);
|
||||
bio = next;
|
||||
}
|
||||
rv = 1;
|
||||
} else
|
||||
spin_unlock_irq(&conf->device_lock);
|
||||
return rv;
|
||||
}
|
||||
|
||||
static void md_kick_device(mddev_t *mddev)
|
||||
{
|
||||
blk_flush_plug(current);
|
||||
md_wakeup_thread(mddev->thread);
|
||||
}
|
||||
|
||||
/* Barriers....
|
||||
|
|
@ -643,8 +600,7 @@ static void raise_barrier(conf_t *conf)
|
|||
|
||||
/* Wait until no block IO is waiting */
|
||||
wait_event_lock_irq(conf->wait_barrier, !conf->nr_waiting,
|
||||
conf->resync_lock,
|
||||
raid1_unplug(conf->mddev->queue));
|
||||
conf->resync_lock, md_kick_device(conf->mddev));
|
||||
|
||||
/* block any new IO from starting */
|
||||
conf->barrier++;
|
||||
|
|
@ -652,8 +608,7 @@ static void raise_barrier(conf_t *conf)
|
|||
/* Now wait for all pending IO to complete */
|
||||
wait_event_lock_irq(conf->wait_barrier,
|
||||
!conf->nr_pending && conf->barrier < RESYNC_DEPTH,
|
||||
conf->resync_lock,
|
||||
raid1_unplug(conf->mddev->queue));
|
||||
conf->resync_lock, md_kick_device(conf->mddev));
|
||||
|
||||
spin_unlock_irq(&conf->resync_lock);
|
||||
}
|
||||
|
|
@ -675,7 +630,7 @@ static void wait_barrier(conf_t *conf)
|
|||
conf->nr_waiting++;
|
||||
wait_event_lock_irq(conf->wait_barrier, !conf->barrier,
|
||||
conf->resync_lock,
|
||||
raid1_unplug(conf->mddev->queue));
|
||||
md_kick_device(conf->mddev));
|
||||
conf->nr_waiting--;
|
||||
}
|
||||
conf->nr_pending++;
|
||||
|
|
@ -712,7 +667,7 @@ static void freeze_array(conf_t *conf)
|
|||
conf->nr_pending == conf->nr_queued+1,
|
||||
conf->resync_lock,
|
||||
({ flush_pending_writes(conf);
|
||||
raid1_unplug(conf->mddev->queue); }));
|
||||
md_kick_device(conf->mddev); }));
|
||||
spin_unlock_irq(&conf->resync_lock);
|
||||
}
|
||||
static void unfreeze_array(conf_t *conf)
|
||||
|
|
@ -962,7 +917,6 @@ static int make_request(mddev_t *mddev, struct bio * bio)
|
|||
atomic_inc(&r1_bio->remaining);
|
||||
spin_lock_irqsave(&conf->device_lock, flags);
|
||||
bio_list_add(&conf->pending_bio_list, mbio);
|
||||
blk_plug_device_unlocked(mddev->queue);
|
||||
spin_unlock_irqrestore(&conf->device_lock, flags);
|
||||
}
|
||||
r1_bio_write_done(r1_bio, bio->bi_vcnt, behind_pages, behind_pages != NULL);
|
||||
|
|
@ -971,7 +925,7 @@ static int make_request(mddev_t *mddev, struct bio * bio)
|
|||
/* In case raid1d snuck in to freeze_array */
|
||||
wake_up(&conf->wait_barrier);
|
||||
|
||||
if (do_sync)
|
||||
if (do_sync || !bitmap)
|
||||
md_wakeup_thread(mddev->thread);
|
||||
|
||||
return 0;
|
||||
|
|
@ -1561,7 +1515,6 @@ static void raid1d(mddev_t *mddev)
|
|||
unsigned long flags;
|
||||
conf_t *conf = mddev->private;
|
||||
struct list_head *head = &conf->retry_list;
|
||||
int unplug=0;
|
||||
mdk_rdev_t *rdev;
|
||||
|
||||
md_check_recovery(mddev);
|
||||
|
|
@ -1569,7 +1522,7 @@ static void raid1d(mddev_t *mddev)
|
|||
for (;;) {
|
||||
char b[BDEVNAME_SIZE];
|
||||
|
||||
unplug += flush_pending_writes(conf);
|
||||
flush_pending_writes(conf);
|
||||
|
||||
spin_lock_irqsave(&conf->device_lock, flags);
|
||||
if (list_empty(head)) {
|
||||
|
|
@ -1583,10 +1536,9 @@ static void raid1d(mddev_t *mddev)
|
|||
|
||||
mddev = r1_bio->mddev;
|
||||
conf = mddev->private;
|
||||
if (test_bit(R1BIO_IsSync, &r1_bio->state)) {
|
||||
if (test_bit(R1BIO_IsSync, &r1_bio->state))
|
||||
sync_request_write(mddev, r1_bio);
|
||||
unplug = 1;
|
||||
} else {
|
||||
else {
|
||||
int disk;
|
||||
|
||||
/* we got a read error. Maybe the drive is bad. Maybe just
|
||||
|
|
@ -1636,14 +1588,11 @@ static void raid1d(mddev_t *mddev)
|
|||
bio->bi_end_io = raid1_end_read_request;
|
||||
bio->bi_rw = READ | do_sync;
|
||||
bio->bi_private = r1_bio;
|
||||
unplug = 1;
|
||||
generic_make_request(bio);
|
||||
}
|
||||
}
|
||||
cond_resched();
|
||||
}
|
||||
if (unplug)
|
||||
unplug_slaves(mddev);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -2066,7 +2015,6 @@ static int run(mddev_t *mddev)
|
|||
|
||||
md_set_array_sectors(mddev, raid1_size(mddev, 0, 0));
|
||||
|
||||
mddev->queue->unplug_fn = raid1_unplug;
|
||||
mddev->queue->backing_dev_info.congested_fn = raid1_congested;
|
||||
mddev->queue->backing_dev_info.congested_data = mddev;
|
||||
md_integrity_register(mddev);
|
||||
|
|
|
|||
|
|
@ -57,23 +57,16 @@
|
|||
*/
|
||||
#define NR_RAID10_BIOS 256
|
||||
|
||||
static void unplug_slaves(mddev_t *mddev);
|
||||
|
||||
static void allow_barrier(conf_t *conf);
|
||||
static void lower_barrier(conf_t *conf);
|
||||
|
||||
static void * r10bio_pool_alloc(gfp_t gfp_flags, void *data)
|
||||
{
|
||||
conf_t *conf = data;
|
||||
r10bio_t *r10_bio;
|
||||
int size = offsetof(struct r10bio_s, devs[conf->copies]);
|
||||
|
||||
/* allocate a r10bio with room for raid_disks entries in the bios array */
|
||||
r10_bio = kzalloc(size, gfp_flags);
|
||||
if (!r10_bio && conf->mddev)
|
||||
unplug_slaves(conf->mddev);
|
||||
|
||||
return r10_bio;
|
||||
return kzalloc(size, gfp_flags);
|
||||
}
|
||||
|
||||
static void r10bio_pool_free(void *r10_bio, void *data)
|
||||
|
|
@ -106,10 +99,8 @@ static void * r10buf_pool_alloc(gfp_t gfp_flags, void *data)
|
|||
int nalloc;
|
||||
|
||||
r10_bio = r10bio_pool_alloc(gfp_flags, conf);
|
||||
if (!r10_bio) {
|
||||
unplug_slaves(conf->mddev);
|
||||
if (!r10_bio)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (test_bit(MD_RECOVERY_SYNC, &conf->mddev->recovery))
|
||||
nalloc = conf->copies; /* resync */
|
||||
|
|
@ -597,37 +588,6 @@ rb_out:
|
|||
return disk;
|
||||
}
|
||||
|
||||
static void unplug_slaves(mddev_t *mddev)
|
||||
{
|
||||
conf_t *conf = mddev->private;
|
||||
int i;
|
||||
|
||||
rcu_read_lock();
|
||||
for (i=0; i < conf->raid_disks; i++) {
|
||||
mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
|
||||
if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
|
||||
struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
|
||||
|
||||
atomic_inc(&rdev->nr_pending);
|
||||
rcu_read_unlock();
|
||||
|
||||
blk_unplug(r_queue);
|
||||
|
||||
rdev_dec_pending(rdev, mddev);
|
||||
rcu_read_lock();
|
||||
}
|
||||
}
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
static void raid10_unplug(struct request_queue *q)
|
||||
{
|
||||
mddev_t *mddev = q->queuedata;
|
||||
|
||||
unplug_slaves(q->queuedata);
|
||||
md_wakeup_thread(mddev->thread);
|
||||
}
|
||||
|
||||
static int raid10_congested(void *data, int bits)
|
||||
{
|
||||
mddev_t *mddev = data;
|
||||
|
|
@ -649,23 +609,16 @@ static int raid10_congested(void *data, int bits)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int flush_pending_writes(conf_t *conf)
|
||||
static void flush_pending_writes(conf_t *conf)
|
||||
{
|
||||
/* Any writes that have been queued but are awaiting
|
||||
* bitmap updates get flushed here.
|
||||
* We return 1 if any requests were actually submitted.
|
||||
*/
|
||||
int rv = 0;
|
||||
|
||||
spin_lock_irq(&conf->device_lock);
|
||||
|
||||
if (conf->pending_bio_list.head) {
|
||||
struct bio *bio;
|
||||
bio = bio_list_get(&conf->pending_bio_list);
|
||||
/* Spinlock only taken to quiet a warning */
|
||||
spin_lock(conf->mddev->queue->queue_lock);
|
||||
blk_remove_plug(conf->mddev->queue);
|
||||
spin_unlock(conf->mddev->queue->queue_lock);
|
||||
spin_unlock_irq(&conf->device_lock);
|
||||
/* flush any pending bitmap writes to disk
|
||||
* before proceeding w/ I/O */
|
||||
|
|
@ -677,11 +630,16 @@ static int flush_pending_writes(conf_t *conf)
|
|||
generic_make_request(bio);
|
||||
bio = next;
|
||||
}
|
||||
rv = 1;
|
||||
} else
|
||||
spin_unlock_irq(&conf->device_lock);
|
||||
return rv;
|
||||
}
|
||||
|
||||
static void md_kick_device(mddev_t *mddev)
|
||||
{
|
||||
blk_flush_plug(current);
|
||||
md_wakeup_thread(mddev->thread);
|
||||
}
|
||||
|
||||
/* Barriers....
|
||||
* Sometimes we need to suspend IO while we do something else,
|
||||
* either some resync/recovery, or reconfigure the array.
|
||||
|
|
@ -711,8 +669,7 @@ static void raise_barrier(conf_t *conf, int force)
|
|||
|
||||
/* Wait until no block IO is waiting (unless 'force') */
|
||||
wait_event_lock_irq(conf->wait_barrier, force || !conf->nr_waiting,
|
||||
conf->resync_lock,
|
||||
raid10_unplug(conf->mddev->queue));
|
||||
conf->resync_lock, md_kick_device(conf->mddev));
|
||||
|
||||
/* block any new IO from starting */
|
||||
conf->barrier++;
|
||||
|
|
@ -720,8 +677,7 @@ static void raise_barrier(conf_t *conf, int force)
|
|||
/* No wait for all pending IO to complete */
|
||||
wait_event_lock_irq(conf->wait_barrier,
|
||||
!conf->nr_pending && conf->barrier < RESYNC_DEPTH,
|
||||
conf->resync_lock,
|
||||
raid10_unplug(conf->mddev->queue));
|
||||
conf->resync_lock, md_kick_device(conf->mddev));
|
||||
|
||||
spin_unlock_irq(&conf->resync_lock);
|
||||
}
|
||||
|
|
@ -742,7 +698,7 @@ static void wait_barrier(conf_t *conf)
|
|||
conf->nr_waiting++;
|
||||
wait_event_lock_irq(conf->wait_barrier, !conf->barrier,
|
||||
conf->resync_lock,
|
||||
raid10_unplug(conf->mddev->queue));
|
||||
md_kick_device(conf->mddev));
|
||||
conf->nr_waiting--;
|
||||
}
|
||||
conf->nr_pending++;
|
||||
|
|
@ -779,7 +735,7 @@ static void freeze_array(conf_t *conf)
|
|||
conf->nr_pending == conf->nr_queued+1,
|
||||
conf->resync_lock,
|
||||
({ flush_pending_writes(conf);
|
||||
raid10_unplug(conf->mddev->queue); }));
|
||||
md_kick_device(conf->mddev); }));
|
||||
spin_unlock_irq(&conf->resync_lock);
|
||||
}
|
||||
|
||||
|
|
@ -974,7 +930,6 @@ static int make_request(mddev_t *mddev, struct bio * bio)
|
|||
atomic_inc(&r10_bio->remaining);
|
||||
spin_lock_irqsave(&conf->device_lock, flags);
|
||||
bio_list_add(&conf->pending_bio_list, mbio);
|
||||
blk_plug_device_unlocked(mddev->queue);
|
||||
spin_unlock_irqrestore(&conf->device_lock, flags);
|
||||
}
|
||||
|
||||
|
|
@ -991,7 +946,7 @@ static int make_request(mddev_t *mddev, struct bio * bio)
|
|||
/* In case raid10d snuck in to freeze_array */
|
||||
wake_up(&conf->wait_barrier);
|
||||
|
||||
if (do_sync)
|
||||
if (do_sync || !mddev->bitmap)
|
||||
md_wakeup_thread(mddev->thread);
|
||||
|
||||
return 0;
|
||||
|
|
@ -1684,7 +1639,6 @@ static void raid10d(mddev_t *mddev)
|
|||
unsigned long flags;
|
||||
conf_t *conf = mddev->private;
|
||||
struct list_head *head = &conf->retry_list;
|
||||
int unplug=0;
|
||||
mdk_rdev_t *rdev;
|
||||
|
||||
md_check_recovery(mddev);
|
||||
|
|
@ -1692,7 +1646,7 @@ static void raid10d(mddev_t *mddev)
|
|||
for (;;) {
|
||||
char b[BDEVNAME_SIZE];
|
||||
|
||||
unplug += flush_pending_writes(conf);
|
||||
flush_pending_writes(conf);
|
||||
|
||||
spin_lock_irqsave(&conf->device_lock, flags);
|
||||
if (list_empty(head)) {
|
||||
|
|
@ -1706,13 +1660,11 @@ static void raid10d(mddev_t *mddev)
|
|||
|
||||
mddev = r10_bio->mddev;
|
||||
conf = mddev->private;
|
||||
if (test_bit(R10BIO_IsSync, &r10_bio->state)) {
|
||||
if (test_bit(R10BIO_IsSync, &r10_bio->state))
|
||||
sync_request_write(mddev, r10_bio);
|
||||
unplug = 1;
|
||||
} else if (test_bit(R10BIO_IsRecover, &r10_bio->state)) {
|
||||
else if (test_bit(R10BIO_IsRecover, &r10_bio->state))
|
||||
recovery_request_write(mddev, r10_bio);
|
||||
unplug = 1;
|
||||
} else {
|
||||
else {
|
||||
int mirror;
|
||||
/* we got a read error. Maybe the drive is bad. Maybe just
|
||||
* the block and we can fix it.
|
||||
|
|
@ -1759,14 +1711,11 @@ static void raid10d(mddev_t *mddev)
|
|||
bio->bi_rw = READ | do_sync;
|
||||
bio->bi_private = r10_bio;
|
||||
bio->bi_end_io = raid10_end_read_request;
|
||||
unplug = 1;
|
||||
generic_make_request(bio);
|
||||
}
|
||||
}
|
||||
cond_resched();
|
||||
}
|
||||
if (unplug)
|
||||
unplug_slaves(mddev);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -2377,7 +2326,6 @@ static int run(mddev_t *mddev)
|
|||
md_set_array_sectors(mddev, size);
|
||||
mddev->resync_max_sectors = size;
|
||||
|
||||
mddev->queue->unplug_fn = raid10_unplug;
|
||||
mddev->queue->backing_dev_info.congested_fn = raid10_congested;
|
||||
mddev->queue->backing_dev_info.congested_data = mddev;
|
||||
|
||||
|
|
|
|||
|
|
@ -433,8 +433,6 @@ static int has_failed(raid5_conf_t *conf)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void unplug_slaves(mddev_t *mddev);
|
||||
|
||||
static struct stripe_head *
|
||||
get_active_stripe(raid5_conf_t *conf, sector_t sector,
|
||||
int previous, int noblock, int noquiesce)
|
||||
|
|
@ -463,8 +461,7 @@ get_active_stripe(raid5_conf_t *conf, sector_t sector,
|
|||
< (conf->max_nr_stripes *3/4)
|
||||
|| !conf->inactive_blocked),
|
||||
conf->device_lock,
|
||||
md_raid5_unplug_device(conf)
|
||||
);
|
||||
md_raid5_kick_device(conf));
|
||||
conf->inactive_blocked = 0;
|
||||
} else
|
||||
init_stripe(sh, sector, previous);
|
||||
|
|
@ -1473,8 +1470,7 @@ static int resize_stripes(raid5_conf_t *conf, int newsize)
|
|||
wait_event_lock_irq(conf->wait_for_stripe,
|
||||
!list_empty(&conf->inactive_list),
|
||||
conf->device_lock,
|
||||
unplug_slaves(conf->mddev)
|
||||
);
|
||||
blk_flush_plug(current));
|
||||
osh = get_free_stripe(conf);
|
||||
spin_unlock_irq(&conf->device_lock);
|
||||
atomic_set(&nsh->count, 1);
|
||||
|
|
@ -3645,58 +3641,19 @@ static void activate_bit_delay(raid5_conf_t *conf)
|
|||
}
|
||||
}
|
||||
|
||||
static void unplug_slaves(mddev_t *mddev)
|
||||
void md_raid5_kick_device(raid5_conf_t *conf)
|
||||
{
|
||||
raid5_conf_t *conf = mddev->private;
|
||||
int i;
|
||||
int devs = max(conf->raid_disks, conf->previous_raid_disks);
|
||||
|
||||
rcu_read_lock();
|
||||
for (i = 0; i < devs; i++) {
|
||||
mdk_rdev_t *rdev = rcu_dereference(conf->disks[i].rdev);
|
||||
if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
|
||||
struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
|
||||
|
||||
atomic_inc(&rdev->nr_pending);
|
||||
rcu_read_unlock();
|
||||
|
||||
blk_unplug(r_queue);
|
||||
|
||||
rdev_dec_pending(rdev, mddev);
|
||||
rcu_read_lock();
|
||||
}
|
||||
}
|
||||
rcu_read_unlock();
|
||||
}
|
||||
|
||||
void md_raid5_unplug_device(raid5_conf_t *conf)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&conf->device_lock, flags);
|
||||
|
||||
if (plugger_remove_plug(&conf->plug)) {
|
||||
conf->seq_flush++;
|
||||
raid5_activate_delayed(conf);
|
||||
}
|
||||
blk_flush_plug(current);
|
||||
raid5_activate_delayed(conf);
|
||||
md_wakeup_thread(conf->mddev->thread);
|
||||
|
||||
spin_unlock_irqrestore(&conf->device_lock, flags);
|
||||
|
||||
unplug_slaves(conf->mddev);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(md_raid5_unplug_device);
|
||||
EXPORT_SYMBOL_GPL(md_raid5_kick_device);
|
||||
|
||||
static void raid5_unplug(struct plug_handle *plug)
|
||||
{
|
||||
raid5_conf_t *conf = container_of(plug, raid5_conf_t, plug);
|
||||
md_raid5_unplug_device(conf);
|
||||
}
|
||||
|
||||
static void raid5_unplug_queue(struct request_queue *q)
|
||||
{
|
||||
mddev_t *mddev = q->queuedata;
|
||||
md_raid5_unplug_device(mddev->private);
|
||||
md_raid5_kick_device(conf);
|
||||
}
|
||||
|
||||
int md_raid5_congested(mddev_t *mddev, int bits)
|
||||
|
|
@ -4100,7 +4057,7 @@ static int make_request(mddev_t *mddev, struct bio * bi)
|
|||
* add failed due to overlap. Flush everything
|
||||
* and wait a while
|
||||
*/
|
||||
md_raid5_unplug_device(conf);
|
||||
md_raid5_kick_device(conf);
|
||||
release_stripe(sh);
|
||||
schedule();
|
||||
goto retry;
|
||||
|
|
@ -4365,7 +4322,6 @@ static inline sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *ski
|
|||
|
||||
if (sector_nr >= max_sector) {
|
||||
/* just being told to finish up .. nothing much to do */
|
||||
unplug_slaves(mddev);
|
||||
|
||||
if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
|
||||
end_reshape(conf);
|
||||
|
|
@ -4569,7 +4525,6 @@ static void raid5d(mddev_t *mddev)
|
|||
spin_unlock_irq(&conf->device_lock);
|
||||
|
||||
async_tx_issue_pending_all();
|
||||
unplug_slaves(mddev);
|
||||
|
||||
pr_debug("--- raid5d inactive\n");
|
||||
}
|
||||
|
|
@ -5204,7 +5159,7 @@ static int run(mddev_t *mddev)
|
|||
|
||||
mddev->queue->backing_dev_info.congested_data = mddev;
|
||||
mddev->queue->backing_dev_info.congested_fn = raid5_congested;
|
||||
mddev->queue->unplug_fn = raid5_unplug_queue;
|
||||
mddev->queue->queue_lock = &conf->device_lock;
|
||||
|
||||
chunk_size = mddev->chunk_sectors << 9;
|
||||
blk_queue_io_min(mddev->queue, chunk_size);
|
||||
|
|
|
|||
|
|
@ -503,6 +503,6 @@ static inline int algorithm_is_DDF(int layout)
|
|||
}
|
||||
|
||||
extern int md_raid5_congested(mddev_t *mddev, int bits);
|
||||
extern void md_raid5_unplug_device(raid5_conf_t *conf);
|
||||
extern void md_raid5_kick_device(raid5_conf_t *conf);
|
||||
extern int raid5_set_cache_size(mddev_t *mddev, int size);
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Reference in a new issue