Merge branch 'ioat-md-accel-for-linus' of git://lost.foo-projects.org/~dwillia2/git/iop

* 'ioat-md-accel-for-linus' of git://lost.foo-projects.org/~dwillia2/git/iop: (28 commits)
  ioatdma: add the unisys "i/oat" pci vendor/device id
  ARM: Add drivers/dma to arch/arm/Kconfig
  iop3xx: surface the iop3xx DMA and AAU units to the iop-adma driver
  iop13xx: surface the iop13xx adma units to the iop-adma driver
  dmaengine: driver for the iop32x, iop33x, and iop13xx raid engines
  md: remove raid5 compute_block and compute_parity5
  md: handle_stripe5 - request io processing in raid5_run_ops
  md: handle_stripe5 - add request/completion logic for async expand ops
  md: handle_stripe5 - add request/completion logic for async read ops
  md: handle_stripe5 - add request/completion logic for async check ops
  md: handle_stripe5 - add request/completion logic for async compute ops
  md: handle_stripe5 - add request/completion logic for async write ops
  md: common infrastructure for running operations with raid5_run_ops
  md: raid5_run_ops - run stripe operations outside sh->lock
  raid5: replace custom debug PRINTKs with standard pr_debug
  raid5: refactor handle_stripe5 and handle_stripe6 (v3)
  async_tx: add the async_tx api
  xor: make 'xor_blocks' a library routine for use with async_tx
  dmaengine: make clients responsible for managing channels
  dmaengine: refactor dmaengine around dma_async_tx_descriptor
  ...

5 files changed, 1685 insertions, 1204 deletions

diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index 466909f38d98..64bf3a81db93 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -109,6 +109,8 @@ config MD_RAID10
 config MD_RAID456
         tristate "RAID-4/RAID-5/RAID-6 mode"
         depends on BLK_DEV_MD
+        select ASYNC_MEMCPY
+        select ASYNC_XOR
         ---help---
           A RAID-5 set of N drives with a capacity of C MB per drive provides
           the capacity of C * (N - 1) MB, and protects against a failure
diff --git a/drivers/md/Makefile b/drivers/md/Makefile
index 2c45d7683ae9..c49366cdc05d 100644
--- a/drivers/md/Makefile
+++ b/drivers/md/Makefile
@@ -18,7 +18,7 @@ raid456-objs	:= raid5.o raid6algos.o raid6recov.o raid6tables.o \
 hostprogs-y     := mktables
 
 # Note: link order is important.  All raid personalities
-# and xor.o must come before md.o, as they each initialise 
+# and must come before md.o, as they each initialise 
 # themselves, and md.o may use the personalities when it 
 # auto-initialised.
 
@@ -26,7 +26,7 @@ obj-$(CONFIG_MD_LINEAR)		+= linear.o
 obj-$(CONFIG_MD_RAID0)          += raid0.o
 obj-$(CONFIG_MD_RAID1)          += raid1.o
 obj-$(CONFIG_MD_RAID10)         += raid10.o
-obj-$(CONFIG_MD_RAID456)        += raid456.o xor.o
+obj-$(CONFIG_MD_RAID456)        += raid456.o
 obj-$(CONFIG_MD_MULTIPATH)      += multipath.o
 obj-$(CONFIG_MD_FAULTY)         += faulty.o
 obj-$(CONFIG_BLK_DEV_MD)        += md-mod.o
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 1c54f3c1cca7..33beaa7da085 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -5814,7 +5814,7 @@ static __exit void md_exit(void)
         }
 }
 
-module_init(md_init)
+subsys_initcall(md_init);
 module_exit(md_exit)
 
 static int get_ro(char *buffer, struct kernel_param *kp)
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 061375ee6592..0b66afef2d82 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -52,6 +52,7 @@
 #include "raid6.h"
 
 #include <linux/raid/bitmap.h>
+#include <linux/async_tx.h>
 
 /*
  * Stripe cache
@@ -80,7 +81,6 @@
 /*
  * The following can be used to debug the driver
  */
-#define RAID5_DEBUG     0
 #define RAID5_PARANOIA  1
 #if RAID5_PARANOIA && defined(CONFIG_SMP)
 # define CHECK_DEVLOCK() assert_spin_locked(&conf->device_lock)
@@ -88,8 +88,7 @@
 # define CHECK_DEVLOCK()
 #endif
 
-#define PRINTK(x...) ((void)(RAID5_DEBUG && printk(x)))
-#if RAID5_DEBUG
+#ifdef DEBUG
 #define inline
 #define __inline__
 #endif
@@ -104,6 +103,23 @@ static inline int raid6_next_disk(int disk, int raid_disks)
         disk++;
         return (disk < raid_disks) ? disk : 0;
 }
+
+static void return_io(struct bio *return_bi)
+{
+        struct bio *bi = return_bi;
+        while (bi) {
+                int bytes = bi->bi_size;
+
+                return_bi = bi->bi_next;
+                bi->bi_next = NULL;
+                bi->bi_size = 0;
+                bi->bi_end_io(bi, bytes,
+                              test_bit(BIO_UPTODATE, &bi->bi_flags)
+                                ? 0 : -EIO);
+                bi = return_bi;
+        }
+}
+
 static void print_raid5_conf (raid5_conf_t *conf);
 
 static void __release_stripe(raid5_conf_t *conf, struct stripe_head *sh)
@@ -125,6 +141,7 @@ static void __release_stripe(raid5_conf_t *conf, struct stripe_head *sh)
                         }
                         md_wakeup_thread(conf->mddev->thread);
                 } else {
+                        BUG_ON(sh->ops.pending);
                         if (test_and_clear_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
                                 atomic_dec(&conf->preread_active_stripes);
                                 if (atomic_read(&conf->preread_active_stripes) < IO_THRESHOLD)
@@ -152,7 +169,8 @@ static void release_stripe(struct stripe_head *sh)
 
 static inline void remove_hash(struct stripe_head *sh)
 {
-        PRINTK("remove_hash(), stripe %llu\n", (unsigned long long)sh->sector);
+        pr_debug("remove_hash(), stripe %llu\n",
+                (unsigned long long)sh->sector);
 
         hlist_del_init(&sh->hash);
 }
@@ -161,7 +179,8 @@ static inline void insert_hash(raid5_conf_t *conf, struct stripe_head *sh)
 {
         struct hlist_head *hp = stripe_hash(conf, sh->sector);
 
-        PRINTK("insert_hash(), stripe %llu\n", (unsigned long long)sh->sector);
+        pr_debug("insert_hash(), stripe %llu\n",
+                (unsigned long long)sh->sector);
 
         CHECK_DEVLOCK();
         hlist_add_head(&sh->hash, hp);
@@ -224,9 +243,10 @@ static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx, int
 
         BUG_ON(atomic_read(&sh->count) != 0);
         BUG_ON(test_bit(STRIPE_HANDLE, &sh->state));
-        
+        BUG_ON(sh->ops.pending || sh->ops.ack || sh->ops.complete);
+
         CHECK_DEVLOCK();
-        PRINTK("init_stripe called, stripe %llu\n", 
+        pr_debug("init_stripe called, stripe %llu\n",
                 (unsigned long long)sh->sector);
 
         remove_hash(sh);
@@ -240,11 +260,11 @@ static void init_stripe(struct stripe_head *sh, sector_t sector, int pd_idx, int
         for (i = sh->disks; i--; ) {
                 struct r5dev *dev = &sh->dev[i];
 
-                if (dev->toread || dev->towrite || dev->written ||
+                if (dev->toread || dev->read || dev->towrite || dev->written ||
                     test_bit(R5_LOCKED, &dev->flags)) {
-                        printk("sector=%llx i=%d %p %p %p %d\n",
+                        printk(KERN_ERR "sector=%llx i=%d %p %p %p %p %d\n",
                                (unsigned long long)sh->sector, i, dev->toread,
-                               dev->towrite, dev->written,
+                               dev->read, dev->towrite, dev->written,
                                test_bit(R5_LOCKED, &dev->flags));
                         BUG();
                 }
@@ -260,11 +280,11 @@ static struct stripe_head *__find_stripe(raid5_conf_t *conf, sector_t sector, in
         struct hlist_node *hn;
 
         CHECK_DEVLOCK();
-        PRINTK("__find_stripe, sector %llu\n", (unsigned long long)sector);
+        pr_debug("__find_stripe, sector %llu\n", (unsigned long long)sector);
         hlist_for_each_entry(sh, hn, stripe_hash(conf, sector), hash)
                 if (sh->sector == sector && sh->disks == disks)
                         return sh;
-        PRINTK("__stripe %llu not in cache\n", (unsigned long long)sector);
+        pr_debug("__stripe %llu not in cache\n", (unsigned long long)sector);
         return NULL;
 }
 
@@ -276,7 +296,7 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
 {
         struct stripe_head *sh;
 
-        PRINTK("get_stripe, sector %llu\n", (unsigned long long)sector);
+        pr_debug("get_stripe, sector %llu\n", (unsigned long long)sector);
 
         spin_lock_irq(&conf->device_lock);
 
@@ -324,6 +344,579 @@ static struct stripe_head *get_active_stripe(raid5_conf_t *conf, sector_t sector
         return sh;
 }
 
+/* test_and_ack_op() ensures that we only dequeue an operation once */
+#define test_and_ack_op(op, pend) \
+do {                                                    \
+        if (test_bit(op, &sh->ops.pending) &&           \
+                !test_bit(op, &sh->ops.complete)) {     \
+                if (test_and_set_bit(op, &sh->ops.ack)) \
+                        clear_bit(op, &pend);           \
+                else                                    \
+                        ack++;                          \
+        } else                                          \
+                clear_bit(op, &pend);                   \
+} while (0)
+
+/* find new work to run, do not resubmit work that is already
+ * in flight
+ */
+static unsigned long get_stripe_work(struct stripe_head *sh)
+{
+        unsigned long pending;
+        int ack = 0;
+
+        pending = sh->ops.pending;
+
+        test_and_ack_op(STRIPE_OP_BIOFILL, pending);
+        test_and_ack_op(STRIPE_OP_COMPUTE_BLK, pending);
+        test_and_ack_op(STRIPE_OP_PREXOR, pending);
+        test_and_ack_op(STRIPE_OP_BIODRAIN, pending);
+        test_and_ack_op(STRIPE_OP_POSTXOR, pending);
+        test_and_ack_op(STRIPE_OP_CHECK, pending);
+        if (test_and_clear_bit(STRIPE_OP_IO, &sh->ops.pending))
+                ack++;
+
+        sh->ops.count -= ack;
+        BUG_ON(sh->ops.count < 0);
+
+        return pending;
+}
+
+static int
+raid5_end_read_request(struct bio *bi, unsigned int bytes_done, int error);
+static int
+raid5_end_write_request (struct bio *bi, unsigned int bytes_done, int error);
+
+static void ops_run_io(struct stripe_head *sh)
+{
+        raid5_conf_t *conf = sh->raid_conf;
+        int i, disks = sh->disks;
+
+        might_sleep();
+
+        for (i = disks; i--; ) {
+                int rw;
+                struct bio *bi;
+                mdk_rdev_t *rdev;
+                if (test_and_clear_bit(R5_Wantwrite, &sh->dev[i].flags))
+                        rw = WRITE;
+                else if (test_and_clear_bit(R5_Wantread, &sh->dev[i].flags))
+                        rw = READ;
+                else
+                        continue;
+
+                bi = &sh->dev[i].req;
+
+                bi->bi_rw = rw;
+                if (rw == WRITE)
+                        bi->bi_end_io = raid5_end_write_request;
+                else
+                        bi->bi_end_io = raid5_end_read_request;
+
+                rcu_read_lock();
+                rdev = rcu_dereference(conf->disks[i].rdev);
+                if (rdev && test_bit(Faulty, &rdev->flags))
+                        rdev = NULL;
+                if (rdev)
+                        atomic_inc(&rdev->nr_pending);
+                rcu_read_unlock();
+
+                if (rdev) {
+                        if (test_bit(STRIPE_SYNCING, &sh->state) ||
+                                test_bit(STRIPE_EXPAND_SOURCE, &sh->state) ||
+                                test_bit(STRIPE_EXPAND_READY, &sh->state))
+                                md_sync_acct(rdev->bdev, STRIPE_SECTORS);
+
+                        bi->bi_bdev = rdev->bdev;
+                        pr_debug("%s: for %llu schedule op %ld on disc %d\n",
+                                __FUNCTION__, (unsigned long long)sh->sector,
+                                bi->bi_rw, i);
+                        atomic_inc(&sh->count);
+                        bi->bi_sector = sh->sector + rdev->data_offset;
+                        bi->bi_flags = 1 << BIO_UPTODATE;
+                        bi->bi_vcnt = 1;
+                        bi->bi_max_vecs = 1;
+                        bi->bi_idx = 0;
+                        bi->bi_io_vec = &sh->dev[i].vec;
+                        bi->bi_io_vec[0].bv_len = STRIPE_SIZE;
+                        bi->bi_io_vec[0].bv_offset = 0;
+                        bi->bi_size = STRIPE_SIZE;
+                        bi->bi_next = NULL;
+                        if (rw == WRITE &&
+                            test_bit(R5_ReWrite, &sh->dev[i].flags))
+                                atomic_add(STRIPE_SECTORS,
+                                        &rdev->corrected_errors);
+                        generic_make_request(bi);
+                } else {
+                        if (rw == WRITE)
+                                set_bit(STRIPE_DEGRADED, &sh->state);
+                        pr_debug("skip op %ld on disc %d for sector %llu\n",
+                                bi->bi_rw, i, (unsigned long long)sh->sector);
+                        clear_bit(R5_LOCKED, &sh->dev[i].flags);
+                        set_bit(STRIPE_HANDLE, &sh->state);
+                }
+        }
+}
+
+static struct dma_async_tx_descriptor *
+async_copy_data(int frombio, struct bio *bio, struct page *page,
+        sector_t sector, struct dma_async_tx_descriptor *tx)
+{
+        struct bio_vec *bvl;
+        struct page *bio_page;
+        int i;
+        int page_offset;
+
+        if (bio->bi_sector >= sector)
+                page_offset = (signed)(bio->bi_sector - sector) * 512;
+        else
+                page_offset = (signed)(sector - bio->bi_sector) * -512;
+        bio_for_each_segment(bvl, bio, i) {
+                int len = bio_iovec_idx(bio, i)->bv_len;
+                int clen;
+                int b_offset = 0;
+
+                if (page_offset < 0) {
+                        b_offset = -page_offset;
+                        page_offset += b_offset;
+                        len -= b_offset;
+                }
+
+                if (len > 0 && page_offset + len > STRIPE_SIZE)
+                        clen = STRIPE_SIZE - page_offset;
+                else
+                        clen = len;
+
+                if (clen > 0) {
+                        b_offset += bio_iovec_idx(bio, i)->bv_offset;
+                        bio_page = bio_iovec_idx(bio, i)->bv_page;
+                        if (frombio)
+                                tx = async_memcpy(page, bio_page, page_offset,
+                                        b_offset, clen,
+                                        ASYNC_TX_DEP_ACK | ASYNC_TX_KMAP_SRC,
+                                        tx, NULL, NULL);
+                        else
+                                tx = async_memcpy(bio_page, page, b_offset,
+                                        page_offset, clen,
+                                        ASYNC_TX_DEP_ACK | ASYNC_TX_KMAP_DST,
+                                        tx, NULL, NULL);
+                }
+                if (clen < len) /* hit end of page */
+                        break;
+                page_offset +=  len;
+        }
+
+        return tx;
+}
+
+static void ops_complete_biofill(void *stripe_head_ref)
+{
+        struct stripe_head *sh = stripe_head_ref;
+        struct bio *return_bi = NULL;
+        raid5_conf_t *conf = sh->raid_conf;
+        int i, more_to_read = 0;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        /* clear completed biofills */
+        for (i = sh->disks; i--; ) {
+                struct r5dev *dev = &sh->dev[i];
+                /* check if this stripe has new incoming reads */
+                if (dev->toread)
+                        more_to_read++;
+
+                /* acknowledge completion of a biofill operation */
+                /* and check if we need to reply to a read request
+                */
+                if (test_bit(R5_Wantfill, &dev->flags) && !dev->toread) {
+                        struct bio *rbi, *rbi2;
+                        clear_bit(R5_Wantfill, &dev->flags);
+
+                        /* The access to dev->read is outside of the
+                         * spin_lock_irq(&conf->device_lock), but is protected
+                         * by the STRIPE_OP_BIOFILL pending bit
+                         */
+                        BUG_ON(!dev->read);
+                        rbi = dev->read;
+                        dev->read = NULL;
+                        while (rbi && rbi->bi_sector <
+                                dev->sector + STRIPE_SECTORS) {
+                                rbi2 = r5_next_bio(rbi, dev->sector);
+                                spin_lock_irq(&conf->device_lock);
+                                if (--rbi->bi_phys_segments == 0) {
+                                        rbi->bi_next = return_bi;
+                                        return_bi = rbi;
+                                }
+                                spin_unlock_irq(&conf->device_lock);
+                                rbi = rbi2;
+                        }
+                }
+        }
+        clear_bit(STRIPE_OP_BIOFILL, &sh->ops.ack);
+        clear_bit(STRIPE_OP_BIOFILL, &sh->ops.pending);
+
+        return_io(return_bi);
+
+        if (more_to_read)
+                set_bit(STRIPE_HANDLE, &sh->state);
+        release_stripe(sh);
+}
+
+static void ops_run_biofill(struct stripe_head *sh)
+{
+        struct dma_async_tx_descriptor *tx = NULL;
+        raid5_conf_t *conf = sh->raid_conf;
+        int i;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        for (i = sh->disks; i--; ) {
+                struct r5dev *dev = &sh->dev[i];
+                if (test_bit(R5_Wantfill, &dev->flags)) {
+                        struct bio *rbi;
+                        spin_lock_irq(&conf->device_lock);
+                        dev->read = rbi = dev->toread;
+                        dev->toread = NULL;
+                        spin_unlock_irq(&conf->device_lock);
+                        while (rbi && rbi->bi_sector <
+                                dev->sector + STRIPE_SECTORS) {
+                                tx = async_copy_data(0, rbi, dev->page,
+                                        dev->sector, tx);
+                                rbi = r5_next_bio(rbi, dev->sector);
+                        }
+                }
+        }
+
+        atomic_inc(&sh->count);
+        async_trigger_callback(ASYNC_TX_DEP_ACK | ASYNC_TX_ACK, tx,
+                ops_complete_biofill, sh);
+}
+
+static void ops_complete_compute5(void *stripe_head_ref)
+{
+        struct stripe_head *sh = stripe_head_ref;
+        int target = sh->ops.target;
+        struct r5dev *tgt = &sh->dev[target];
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        set_bit(R5_UPTODATE, &tgt->flags);
+        BUG_ON(!test_bit(R5_Wantcompute, &tgt->flags));
+        clear_bit(R5_Wantcompute, &tgt->flags);
+        set_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete);
+        set_bit(STRIPE_HANDLE, &sh->state);
+        release_stripe(sh);
+}
+
+static struct dma_async_tx_descriptor *
+ops_run_compute5(struct stripe_head *sh, unsigned long pending)
+{
+        /* kernel stack size limits the total number of disks */
+        int disks = sh->disks;
+        struct page *xor_srcs[disks];
+        int target = sh->ops.target;
+        struct r5dev *tgt = &sh->dev[target];
+        struct page *xor_dest = tgt->page;
+        int count = 0;
+        struct dma_async_tx_descriptor *tx;
+        int i;
+
+        pr_debug("%s: stripe %llu block: %d\n",
+                __FUNCTION__, (unsigned long long)sh->sector, target);
+        BUG_ON(!test_bit(R5_Wantcompute, &tgt->flags));
+
+        for (i = disks; i--; )
+                if (i != target)
+                        xor_srcs[count++] = sh->dev[i].page;
+
+        atomic_inc(&sh->count);
+
+        if (unlikely(count == 1))
+                tx = async_memcpy(xor_dest, xor_srcs[0], 0, 0, STRIPE_SIZE,
+                        0, NULL, ops_complete_compute5, sh);
+        else
+                tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
+                        ASYNC_TX_XOR_ZERO_DST, NULL,
+                        ops_complete_compute5, sh);
+
+        /* ack now if postxor is not set to be run */
+        if (tx && !test_bit(STRIPE_OP_POSTXOR, &pending))
+                async_tx_ack(tx);
+
+        return tx;
+}
+
+static void ops_complete_prexor(void *stripe_head_ref)
+{
+        struct stripe_head *sh = stripe_head_ref;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        set_bit(STRIPE_OP_PREXOR, &sh->ops.complete);
+}
+
+static struct dma_async_tx_descriptor *
+ops_run_prexor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
+{
+        /* kernel stack size limits the total number of disks */
+        int disks = sh->disks;
+        struct page *xor_srcs[disks];
+        int count = 0, pd_idx = sh->pd_idx, i;
+
+        /* existing parity data subtracted */
+        struct page *xor_dest = xor_srcs[count++] = sh->dev[pd_idx].page;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        for (i = disks; i--; ) {
+                struct r5dev *dev = &sh->dev[i];
+                /* Only process blocks that are known to be uptodate */
+                if (dev->towrite && test_bit(R5_Wantprexor, &dev->flags))
+                        xor_srcs[count++] = dev->page;
+        }
+
+        tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
+                ASYNC_TX_DEP_ACK | ASYNC_TX_XOR_DROP_DST, tx,
+                ops_complete_prexor, sh);
+
+        return tx;
+}
+
+static struct dma_async_tx_descriptor *
+ops_run_biodrain(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
+{
+        int disks = sh->disks;
+        int pd_idx = sh->pd_idx, i;
+
+        /* check if prexor is active which means only process blocks
+         * that are part of a read-modify-write (Wantprexor)
+         */
+        int prexor = test_bit(STRIPE_OP_PREXOR, &sh->ops.pending);
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        for (i = disks; i--; ) {
+                struct r5dev *dev = &sh->dev[i];
+                struct bio *chosen;
+                int towrite;
+
+                towrite = 0;
+                if (prexor) { /* rmw */
+                        if (dev->towrite &&
+                            test_bit(R5_Wantprexor, &dev->flags))
+                                towrite = 1;
+                } else { /* rcw */
+                        if (i != pd_idx && dev->towrite &&
+                                test_bit(R5_LOCKED, &dev->flags))
+                                towrite = 1;
+                }
+
+                if (towrite) {
+                        struct bio *wbi;
+
+                        spin_lock(&sh->lock);
+                        chosen = dev->towrite;
+                        dev->towrite = NULL;
+                        BUG_ON(dev->written);
+                        wbi = dev->written = chosen;
+                        spin_unlock(&sh->lock);
+
+                        while (wbi && wbi->bi_sector <
+                                dev->sector + STRIPE_SECTORS) {
+                                tx = async_copy_data(1, wbi, dev->page,
+                                        dev->sector, tx);
+                                wbi = r5_next_bio(wbi, dev->sector);
+                        }
+                }
+        }
+
+        return tx;
+}
+
+static void ops_complete_postxor(void *stripe_head_ref)
+{
+        struct stripe_head *sh = stripe_head_ref;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        set_bit(STRIPE_OP_POSTXOR, &sh->ops.complete);
+        set_bit(STRIPE_HANDLE, &sh->state);
+        release_stripe(sh);
+}
+
+static void ops_complete_write(void *stripe_head_ref)
+{
+        struct stripe_head *sh = stripe_head_ref;
+        int disks = sh->disks, i, pd_idx = sh->pd_idx;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        for (i = disks; i--; ) {
+                struct r5dev *dev = &sh->dev[i];
+                if (dev->written || i == pd_idx)
+                        set_bit(R5_UPTODATE, &dev->flags);
+        }
+
+        set_bit(STRIPE_OP_BIODRAIN, &sh->ops.complete);
+        set_bit(STRIPE_OP_POSTXOR, &sh->ops.complete);
+
+        set_bit(STRIPE_HANDLE, &sh->state);
+        release_stripe(sh);
+}
+
+static void
+ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
+{
+        /* kernel stack size limits the total number of disks */
+        int disks = sh->disks;
+        struct page *xor_srcs[disks];
+
+        int count = 0, pd_idx = sh->pd_idx, i;
+        struct page *xor_dest;
+        int prexor = test_bit(STRIPE_OP_PREXOR, &sh->ops.pending);
+        unsigned long flags;
+        dma_async_tx_callback callback;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        /* check if prexor is active which means only process blocks
+         * that are part of a read-modify-write (written)
+         */
+        if (prexor) {
+                xor_dest = xor_srcs[count++] = sh->dev[pd_idx].page;
+                for (i = disks; i--; ) {
+                        struct r5dev *dev = &sh->dev[i];
+                        if (dev->written)
+                                xor_srcs[count++] = dev->page;
+                }
+        } else {
+                xor_dest = sh->dev[pd_idx].page;
+                for (i = disks; i--; ) {
+                        struct r5dev *dev = &sh->dev[i];
+                        if (i != pd_idx)
+                                xor_srcs[count++] = dev->page;
+                }
+        }
+
+        /* check whether this postxor is part of a write */
+        callback = test_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending) ?
+                ops_complete_write : ops_complete_postxor;
+
+        /* 1/ if we prexor'd then the dest is reused as a source
+         * 2/ if we did not prexor then we are redoing the parity
+         * set ASYNC_TX_XOR_DROP_DST and ASYNC_TX_XOR_ZERO_DST
+         * for the synchronous xor case
+         */
+        flags = ASYNC_TX_DEP_ACK | ASYNC_TX_ACK |
+                (prexor ? ASYNC_TX_XOR_DROP_DST : ASYNC_TX_XOR_ZERO_DST);
+
+        atomic_inc(&sh->count);
+
+        if (unlikely(count == 1)) {
+                flags &= ~(ASYNC_TX_XOR_DROP_DST | ASYNC_TX_XOR_ZERO_DST);
+                tx = async_memcpy(xor_dest, xor_srcs[0], 0, 0, STRIPE_SIZE,
+                        flags, tx, callback, sh);
+        } else
+                tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
+                        flags, tx, callback, sh);
+}
+
+static void ops_complete_check(void *stripe_head_ref)
+{
+        struct stripe_head *sh = stripe_head_ref;
+        int pd_idx = sh->pd_idx;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        if (test_and_clear_bit(STRIPE_OP_MOD_DMA_CHECK, &sh->ops.pending) &&
+                sh->ops.zero_sum_result == 0)
+                set_bit(R5_UPTODATE, &sh->dev[pd_idx].flags);
+
+        set_bit(STRIPE_OP_CHECK, &sh->ops.complete);
+        set_bit(STRIPE_HANDLE, &sh->state);
+        release_stripe(sh);
+}
+
+static void ops_run_check(struct stripe_head *sh)
+{
+        /* kernel stack size limits the total number of disks */
+        int disks = sh->disks;
+        struct page *xor_srcs[disks];
+        struct dma_async_tx_descriptor *tx;
+
+        int count = 0, pd_idx = sh->pd_idx, i;
+        struct page *xor_dest = xor_srcs[count++] = sh->dev[pd_idx].page;
+
+        pr_debug("%s: stripe %llu\n", __FUNCTION__,
+                (unsigned long long)sh->sector);
+
+        for (i = disks; i--; ) {
+                struct r5dev *dev = &sh->dev[i];
+                if (i != pd_idx)
+                        xor_srcs[count++] = dev->page;
+        }
+
+        tx = async_xor_zero_sum(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
+                &sh->ops.zero_sum_result, 0, NULL, NULL, NULL);
+
+        if (tx)
+                set_bit(STRIPE_OP_MOD_DMA_CHECK, &sh->ops.pending);
+        else
+                clear_bit(STRIPE_OP_MOD_DMA_CHECK, &sh->ops.pending);
+
+        atomic_inc(&sh->count);
+        tx = async_trigger_callback(ASYNC_TX_DEP_ACK | ASYNC_TX_ACK, tx,
+                ops_complete_check, sh);
+}
+
+static void raid5_run_ops(struct stripe_head *sh, unsigned long pending)
+{
+        int overlap_clear = 0, i, disks = sh->disks;
+        struct dma_async_tx_descriptor *tx = NULL;
+
+        if (test_bit(STRIPE_OP_BIOFILL, &pending)) {
+                ops_run_biofill(sh);
+                overlap_clear++;
+        }
+
+        if (test_bit(STRIPE_OP_COMPUTE_BLK, &pending))
+                tx = ops_run_compute5(sh, pending);
+
+        if (test_bit(STRIPE_OP_PREXOR, &pending))
+                tx = ops_run_prexor(sh, tx);
+
+        if (test_bit(STRIPE_OP_BIODRAIN, &pending)) {
+                tx = ops_run_biodrain(sh, tx);
+                overlap_clear++;
+        }
+
+        if (test_bit(STRIPE_OP_POSTXOR, &pending))
+                ops_run_postxor(sh, tx);
+
+        if (test_bit(STRIPE_OP_CHECK, &pending))
+                ops_run_check(sh);
+
+        if (test_bit(STRIPE_OP_IO, &pending))
+                ops_run_io(sh);
+
+        if (overlap_clear)
+                for (i = disks; i--; ) {
+                        struct r5dev *dev = &sh->dev[i];
+                        if (test_and_clear_bit(R5_Overlap, &dev->flags))
+                                wake_up(&sh->raid_conf->wait_for_overlap);
+                }
+}
+
 static int grow_one_stripe(raid5_conf_t *conf)
 {
         struct stripe_head *sh;
@@ -537,8 +1130,8 @@ static int raid5_end_read_request(struct bio * bi, unsigned int bytes_done,
                 if (bi == &sh->dev[i].req)
                         break;
 
-        PRINTK("end_read_request %llu/%d, count: %d, uptodate %d.\n", 
-                (unsigned long long)sh->sector, i, atomic_read(&sh->count), 
+        pr_debug("end_read_request %llu/%d, count: %d, uptodate %d.\n",
+                (unsigned long long)sh->sector, i, atomic_read(&sh->count),
                 uptodate);
         if (i == disks) {
                 BUG();
@@ -613,7 +1206,7 @@ static int raid5_end_write_request (struct bio *bi, unsigned int bytes_done,
                 if (bi == &sh->dev[i].req)
                         break;
 
-        PRINTK("end_write_request %llu/%d, count %d, uptodate: %d.\n", 
+        pr_debug("end_write_request %llu/%d, count %d, uptodate: %d.\n",
                 (unsigned long long)sh->sector, i, atomic_read(&sh->count),
                 uptodate);
         if (i == disks) {
@@ -658,7 +1251,7 @@ static void error(mddev_t *mddev, mdk_rdev_t *rdev)
 {
         char b[BDEVNAME_SIZE];
         raid5_conf_t *conf = (raid5_conf_t *) mddev->private;
-        PRINTK("raid5: error called\n");
+        pr_debug("raid5: error called\n");
 
         if (!test_bit(Faulty, &rdev->flags)) {
                 set_bit(MD_CHANGE_DEVS, &mddev->flags);
@@ -916,137 +1509,13 @@ static void copy_data(int frombio, struct bio *bio,
         }
 }
 
-#define check_xor()     do {                                            \
-                           if (count == MAX_XOR_BLOCKS) {               \
-                                xor_block(count, STRIPE_SIZE, ptr);     \
-                                count = 1;                              \
-                           }                                            \
+#define check_xor()     do {                                              \
+                                if (count == MAX_XOR_BLOCKS) {            \
+                                xor_blocks(count, STRIPE_SIZE, dest, ptr);\
+                                count = 0;                                \
+                           }                                              \
                         } while(0)
 
-
-static void compute_block(struct stripe_head *sh, int dd_idx)
-{
-        int i, count, disks = sh->disks;
-        void *ptr[MAX_XOR_BLOCKS], *p;
-
-        PRINTK("compute_block, stripe %llu, idx %d\n", 
-                (unsigned long long)sh->sector, dd_idx);
-
-        ptr[0] = page_address(sh->dev[dd_idx].page);
-        memset(ptr[0], 0, STRIPE_SIZE);
-        count = 1;
-        for (i = disks ; i--; ) {
-                if (i == dd_idx)
-                        continue;
-                p = page_address(sh->dev[i].page);
-                if (test_bit(R5_UPTODATE, &sh->dev[i].flags))
-                        ptr[count++] = p;
-                else
-                        printk(KERN_ERR "compute_block() %d, stripe %llu, %d"
-                                " not present\n", dd_idx,
-                                (unsigned long long)sh->sector, i);
-
-                check_xor();
-        }
-        if (count != 1)
-                xor_block(count, STRIPE_SIZE, ptr);
-        set_bit(R5_UPTODATE, &sh->dev[dd_idx].flags);
-}
-
-static void compute_parity5(struct stripe_head *sh, int method)
-{
-        raid5_conf_t *conf = sh->raid_conf;
-        int i, pd_idx = sh->pd_idx, disks = sh->disks, count;
-        void *ptr[MAX_XOR_BLOCKS];
-        struct bio *chosen;
-
-        PRINTK("compute_parity5, stripe %llu, method %d\n",
-                (unsigned long long)sh->sector, method);
-
-        count = 1;
-        ptr[0] = page_address(sh->dev[pd_idx].page);
-        switch(method) {
-        case READ_MODIFY_WRITE:
-                BUG_ON(!test_bit(R5_UPTODATE, &sh->dev[pd_idx].flags));
-                for (i=disks ; i-- ;) {
-                        if (i==pd_idx)
-                                continue;
-                        if (sh->dev[i].towrite &&
-                            test_bit(R5_UPTODATE, &sh->dev[i].flags)) {
-                                ptr[count++] = page_address(sh->dev[i].page);
-                                chosen = sh->dev[i].towrite;
-                                sh->dev[i].towrite = NULL;
-
-                                if (test_and_clear_bit(R5_Overlap, &sh->dev[i].flags))
-                                        wake_up(&conf->wait_for_overlap);
-
-                                BUG_ON(sh->dev[i].written);
-                                sh->dev[i].written = chosen;
-                                check_xor();
-                        }
-                }
-                break;
-        case RECONSTRUCT_WRITE:
-                memset(ptr[0], 0, STRIPE_SIZE);
-                for (i= disks; i-- ;)
-                        if (i!=pd_idx && sh->dev[i].towrite) {
-                                chosen = sh->dev[i].towrite;
-                                sh->dev[i].towrite = NULL;
-
-                                if (test_and_clear_bit(R5_Overlap, &sh->dev[i].flags))
-                                        wake_up(&conf->wait_for_overlap);
-
-                                BUG_ON(sh->dev[i].written);
-                                sh->dev[i].written = chosen;
-                        }
-                break;
-        case CHECK_PARITY:
-                break;
-        }
-        if (count>1) {
-                xor_block(count, STRIPE_SIZE, ptr);
-                count = 1;
-        }
-        
-        for (i = disks; i--;)
-                if (sh->dev[i].written) {
-                        sector_t sector = sh->dev[i].sector;
-                        struct bio *wbi = sh->dev[i].written;
-                        while (wbi && wbi->bi_sector < sector + STRIPE_SECTORS) {
-                                copy_data(1, wbi, sh->dev[i].page, sector);
-                                wbi = r5_next_bio(wbi, sector);
-                        }
-
-                        set_bit(R5_LOCKED, &sh->dev[i].flags);
-                        set_bit(R5_UPTODATE, &sh->dev[i].flags);
-                }
-
-        switch(method) {
-        case RECONSTRUCT_WRITE:
-        case CHECK_PARITY:
-                for (i=disks; i--;)
-                        if (i != pd_idx) {
-                                ptr[count++] = page_address(sh->dev[i].page);
-                                check_xor();
-                        }
-                break;
-        case READ_MODIFY_WRITE:
-                for (i = disks; i--;)
-                        if (sh->dev[i].written) {
-                                ptr[count++] = page_address(sh->dev[i].page);
-                                check_xor();
-                        }
-        }
-        if (count != 1)
-                xor_block(count, STRIPE_SIZE, ptr);
-        
-        if (method != CHECK_PARITY) {
-                set_bit(R5_UPTODATE, &sh->dev[pd_idx].flags);
-                set_bit(R5_LOCKED,   &sh->dev[pd_idx].flags);
-        } else
-                clear_bit(R5_UPTODATE, &sh->dev[pd_idx].flags);
-}
-
 static void compute_parity6(struct stripe_head *sh, int method)
 {
         raid6_conf_t *conf = sh->raid_conf;
@@ -1058,7 +1527,7 @@ static void compute_parity6(struct stripe_head *sh, int method)
         qd_idx = raid6_next_disk(pd_idx, disks);
         d0_idx = raid6_next_disk(qd_idx, disks);
 
-        PRINTK("compute_parity, stripe %llu, method %d\n",
+        pr_debug("compute_parity, stripe %llu, method %d\n",
                 (unsigned long long)sh->sector, method);
 
         switch(method) {
@@ -1132,20 +1601,20 @@ static void compute_parity6(struct stripe_head *sh, int method)
 static void compute_block_1(struct stripe_head *sh, int dd_idx, int nozero)
 {
         int i, count, disks = sh->disks;
-        void *ptr[MAX_XOR_BLOCKS], *p;
+        void *ptr[MAX_XOR_BLOCKS], *dest, *p;
         int pd_idx = sh->pd_idx;
         int qd_idx = raid6_next_disk(pd_idx, disks);
 
-        PRINTK("compute_block_1, stripe %llu, idx %d\n",
+        pr_debug("compute_block_1, stripe %llu, idx %d\n",
                 (unsigned long long)sh->sector, dd_idx);
 
         if ( dd_idx == qd_idx ) {
                 /* We're actually computing the Q drive */
                 compute_parity6(sh, UPDATE_PARITY);
         } else {
-                ptr[0] = page_address(sh->dev[dd_idx].page);
-                if (!nozero) memset(ptr[0], 0, STRIPE_SIZE);
-                count = 1;
+                dest = page_address(sh->dev[dd_idx].page);
+                if (!nozero) memset(dest, 0, STRIPE_SIZE);
+                count = 0;
                 for (i = disks ; i--; ) {
                         if (i == dd_idx || i == qd_idx)
                                 continue;
@@ -1159,8 +1628,8 @@ static void compute_block_1(struct stripe_head *sh, int dd_idx, int nozero)
 
                         check_xor();
                 }
-                if (count != 1)
-                        xor_block(count, STRIPE_SIZE, ptr);
+                if (count)
+                        xor_blocks(count, STRIPE_SIZE, dest, ptr);
                 if (!nozero) set_bit(R5_UPTODATE, &sh->dev[dd_idx].flags);
                 else clear_bit(R5_UPTODATE, &sh->dev[dd_idx].flags);
         }
@@ -1183,7 +1652,7 @@ static void compute_block_2(struct stripe_head *sh, int dd_idx1, int dd_idx2)
         BUG_ON(faila == failb);
         if ( failb < faila ) { int tmp = faila; faila = failb; failb = tmp; }
 
-        PRINTK("compute_block_2, stripe %llu, idx %d,%d (%d,%d)\n",
+        pr_debug("compute_block_2, stripe %llu, idx %d,%d (%d,%d)\n",
                (unsigned long long)sh->sector, dd_idx1, dd_idx2, faila, failb);
 
         if ( failb == disks-1 ) {
@@ -1229,7 +1698,79 @@ static void compute_block_2(struct stripe_head *sh, int dd_idx1, int dd_idx2)
         }
 }
 
+static int
+handle_write_operations5(struct stripe_head *sh, int rcw, int expand)
+{
+        int i, pd_idx = sh->pd_idx, disks = sh->disks;
+        int locked = 0;
 
+        if (rcw) {
+                /* if we are not expanding this is a proper write request, and
+                 * there will be bios with new data to be drained into the
+                 * stripe cache
+                 */
+                if (!expand) {
+                        set_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending);
+                        sh->ops.count++;
+                }
+
+                set_bit(STRIPE_OP_POSTXOR, &sh->ops.pending);
+                sh->ops.count++;
+
+                for (i = disks; i--; ) {
+                        struct r5dev *dev = &sh->dev[i];
+
+                        if (dev->towrite) {
+                                set_bit(R5_LOCKED, &dev->flags);
+                                if (!expand)
+                                        clear_bit(R5_UPTODATE, &dev->flags);
+                                locked++;
+                        }
+                }
+        } else {
+                BUG_ON(!(test_bit(R5_UPTODATE, &sh->dev[pd_idx].flags) ||
+                        test_bit(R5_Wantcompute, &sh->dev[pd_idx].flags)));
+
+                set_bit(STRIPE_OP_PREXOR, &sh->ops.pending);
+                set_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending);
+                set_bit(STRIPE_OP_POSTXOR, &sh->ops.pending);
+
+                sh->ops.count += 3;
+
+                for (i = disks; i--; ) {
+                        struct r5dev *dev = &sh->dev[i];
+                        if (i == pd_idx)
+                                continue;
+
+                        /* For a read-modify write there may be blocks that are
+                         * locked for reading while others are ready to be
+                         * written so we distinguish these blocks by the
+                         * R5_Wantprexor bit
+                         */
+                        if (dev->towrite &&
+                            (test_bit(R5_UPTODATE, &dev->flags) ||
+                            test_bit(R5_Wantcompute, &dev->flags))) {
+                                set_bit(R5_Wantprexor, &dev->flags);
+                                set_bit(R5_LOCKED, &dev->flags);
+                                clear_bit(R5_UPTODATE, &dev->flags);
+                                locked++;
+                        }
+                }
+        }
+
+        /* keep the parity disk locked while asynchronous operations
+         * are in flight
+         */
+        set_bit(R5_LOCKED, &sh->dev[pd_idx].flags);
+        clear_bit(R5_UPTODATE, &sh->dev[pd_idx].flags);
+        locked++;
+
+        pr_debug("%s: stripe %llu locked: %d pending: %lx\n",
+                __FUNCTION__, (unsigned long long)sh->sector,
+                locked, sh->ops.pending);
+
+        return locked;
+}
 
 /*
  * Each stripe/dev can have one or more bion attached.
@@ -1242,7 +1783,7 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
         raid5_conf_t *conf = sh->raid_conf;
         int firstwrite=0;
 
-        PRINTK("adding bh b#%llu to stripe s#%llu\n",
+        pr_debug("adding bh b#%llu to stripe s#%llu\n",
                 (unsigned long long)bi->bi_sector,
                 (unsigned long long)sh->sector);
 
@@ -1271,7 +1812,7 @@ static int add_stripe_bio(struct stripe_head *sh, struct bio *bi, int dd_idx, in
         spin_unlock_irq(&conf->device_lock);
         spin_unlock(&sh->lock);
 
-        PRINTK("added bi b#%llu to stripe s#%llu, disk %d.\n",
+        pr_debug("added bi b#%llu to stripe s#%llu, disk %d.\n",
                 (unsigned long long)bi->bi_sector,
                 (unsigned long long)sh->sector, dd_idx);
 
@@ -1326,6 +1867,729 @@ static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int disks)
         return pd_idx;
 }
 
+static void
+handle_requests_to_failed_array(raid5_conf_t *conf, struct stripe_head *sh,
+                                struct stripe_head_state *s, int disks,
+                                struct bio **return_bi)
+{
+        int i;
+        for (i = disks; i--; ) {
+                struct bio *bi;
+                int bitmap_end = 0;
+
+                if (test_bit(R5_ReadError, &sh->dev[i].flags)) {
+                        mdk_rdev_t *rdev;
+                        rcu_read_lock();
+                        rdev = rcu_dereference(conf->disks[i].rdev);
+                        if (rdev && test_bit(In_sync, &rdev->flags))
+                                /* multiple read failures in one stripe */
+                                md_error(conf->mddev, rdev);
+                        rcu_read_unlock();
+                }
+                spin_lock_irq(&conf->device_lock);
+                /* fail all writes first */
+                bi = sh->dev[i].towrite;
+                sh->dev[i].towrite = NULL;
+                if (bi) {
+                        s->to_write--;
+                        bitmap_end = 1;
+                }
+
+                if (test_and_clear_bit(R5_Overlap, &sh->dev[i].flags))
+                        wake_up(&conf->wait_for_overlap);
+
+                while (bi && bi->bi_sector <
+                        sh->dev[i].sector + STRIPE_SECTORS) {
+                        struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);
+                        clear_bit(BIO_UPTODATE, &bi->bi_flags);
+                        if (--bi->bi_phys_segments == 0) {
+                                md_write_end(conf->mddev);
+                                bi->bi_next = *return_bi;
+                                *return_bi = bi;
+                        }
+                        bi = nextbi;
+                }
+                /* and fail all 'written' */
+                bi = sh->dev[i].written;
+                sh->dev[i].written = NULL;
+                if (bi) bitmap_end = 1;
+                while (bi && bi->bi_sector <
+                       sh->dev[i].sector + STRIPE_SECTORS) {
+                        struct bio *bi2 = r5_next_bio(bi, sh->dev[i].sector);
+                        clear_bit(BIO_UPTODATE, &bi->bi_flags);
+                        if (--bi->bi_phys_segments == 0) {
+                                md_write_end(conf->mddev);
+                                bi->bi_next = *return_bi;
+                                *return_bi = bi;
+                        }
+                        bi = bi2;
+                }
+
+                /* fail any reads if this device is non-operational and
+                 * the data has not reached the cache yet.
+                 */
+                if (!test_bit(R5_Wantfill, &sh->dev[i].flags) &&
+                    (!test_bit(R5_Insync, &sh->dev[i].flags) ||
+                      test_bit(R5_ReadError, &sh->dev[i].flags))) {
+                        bi = sh->dev[i].toread;
+                        sh->dev[i].toread = NULL;
+                        if (test_and_clear_bit(R5_Overlap, &sh->dev[i].flags))
+                                wake_up(&conf->wait_for_overlap);
+                        if (bi) s->to_read--;
+                        while (bi && bi->bi_sector <
+                               sh->dev[i].sector + STRIPE_SECTORS) {
+                                struct bio *nextbi =
+                                        r5_next_bio(bi, sh->dev[i].sector);
+                                clear_bit(BIO_UPTODATE, &bi->bi_flags);
+                                if (--bi->bi_phys_segments == 0) {
+                                        bi->bi_next = *return_bi;
+                                        *return_bi = bi;
+                                }
+                                bi = nextbi;
+                        }
+                }
+                spin_unlock_irq(&conf->device_lock);
+                if (bitmap_end)
+                        bitmap_endwrite(conf->mddev->bitmap, sh->sector,
+                                        STRIPE_SECTORS, 0, 0);
+        }
+
+}
+
+/* __handle_issuing_new_read_requests5 - returns 0 if there are no more disks
+ * to process
+ */
+static int __handle_issuing_new_read_requests5(struct stripe_head *sh,
+                        struct stripe_head_state *s, int disk_idx, int disks)
+{
+        struct r5dev *dev = &sh->dev[disk_idx];
+        struct r5dev *failed_dev = &sh->dev[s->failed_num];
+
+        /* don't schedule compute operations or reads on the parity block while
+         * a check is in flight
+         */
+        if ((disk_idx == sh->pd_idx) &&
+             test_bit(STRIPE_OP_CHECK, &sh->ops.pending))
+                return ~0;
+
+        /* is the data in this block needed, and can we get it? */
+        if (!test_bit(R5_LOCKED, &dev->flags) &&
+            !test_bit(R5_UPTODATE, &dev->flags) && (dev->toread ||
+            (dev->towrite && !test_bit(R5_OVERWRITE, &dev->flags)) ||
+             s->syncing || s->expanding || (s->failed &&
+             (failed_dev->toread || (failed_dev->towrite &&
+             !test_bit(R5_OVERWRITE, &failed_dev->flags)
+             ))))) {
+                /* 1/ We would like to get this block, possibly by computing it,
+                 * but we might not be able to.
+                 *
+                 * 2/ Since parity check operations potentially make the parity
+                 * block !uptodate it will need to be refreshed before any
+                 * compute operations on data disks are scheduled.
+                 *
+                 * 3/ We hold off parity block re-reads until check operations
+                 * have quiesced.
+                 */
+                if ((s->uptodate == disks - 1) &&
+                    !test_bit(STRIPE_OP_CHECK, &sh->ops.pending)) {
+                        set_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending);
+                        set_bit(R5_Wantcompute, &dev->flags);
+                        sh->ops.target = disk_idx;
+                        s->req_compute = 1;
+                        sh->ops.count++;
+                        /* Careful: from this point on 'uptodate' is in the eye
+                         * of raid5_run_ops which services 'compute' operations
+                         * before writes. R5_Wantcompute flags a block that will
+                         * be R5_UPTODATE by the time it is needed for a
+                         * subsequent operation.
+                         */
+                        s->uptodate++;
+                        return 0; /* uptodate + compute == disks */
+                } else if ((s->uptodate < disks - 1) &&
+                        test_bit(R5_Insync, &dev->flags)) {
+                        /* Note: we hold off compute operations while checks are
+                         * in flight, but we still prefer 'compute' over 'read'
+                         * hence we only read if (uptodate < * disks-1)
+                         */
+                        set_bit(R5_LOCKED, &dev->flags);
+                        set_bit(R5_Wantread, &dev->flags);
+                        if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
+                                sh->ops.count++;
+                        s->locked++;
+                        pr_debug("Reading block %d (sync=%d)\n", disk_idx,
+                                s->syncing);
+                }
+        }
+
+        return ~0;
+}
+
+static void handle_issuing_new_read_requests5(struct stripe_head *sh,
+                        struct stripe_head_state *s, int disks)
+{
+        int i;
+
+        /* Clear completed compute operations.  Parity recovery
+         * (STRIPE_OP_MOD_REPAIR_PD) implies a write-back which is handled
+         * later on in this routine
+         */
+        if (test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete) &&
+                !test_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending)) {
+                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete);
+                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.ack);
+                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending);
+        }
+
+        /* look for blocks to read/compute, skip this if a compute
+         * is already in flight, or if the stripe contents are in the
+         * midst of changing due to a write
+         */
+        if (!test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending) &&
+                !test_bit(STRIPE_OP_PREXOR, &sh->ops.pending) &&
+                !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending)) {
+                for (i = disks; i--; )
+                        if (__handle_issuing_new_read_requests5(
+                                sh, s, i, disks) == 0)
+                                break;
+        }
+        set_bit(STRIPE_HANDLE, &sh->state);
+}
+
+static void handle_issuing_new_read_requests6(struct stripe_head *sh,
+                        struct stripe_head_state *s, struct r6_state *r6s,
+                        int disks)
+{
+        int i;
+        for (i = disks; i--; ) {
+                struct r5dev *dev = &sh->dev[i];
+                if (!test_bit(R5_LOCKED, &dev->flags) &&
+                    !test_bit(R5_UPTODATE, &dev->flags) &&
+                    (dev->toread || (dev->towrite &&
+                     !test_bit(R5_OVERWRITE, &dev->flags)) ||
+                     s->syncing || s->expanding ||
+                     (s->failed >= 1 &&
+                      (sh->dev[r6s->failed_num[0]].toread ||
+                       s->to_write)) ||
+                     (s->failed >= 2 &&
+                      (sh->dev[r6s->failed_num[1]].toread ||
+                       s->to_write)))) {
+                        /* we would like to get this block, possibly
+                         * by computing it, but we might not be able to
+                         */
+                        if (s->uptodate == disks-1) {
+                                pr_debug("Computing stripe %llu block %d\n",
+                                       (unsigned long long)sh->sector, i);
+                                compute_block_1(sh, i, 0);
+                                s->uptodate++;
+                        } else if ( s->uptodate == disks-2 && s->failed >= 2 ) {
+                                /* Computing 2-failure is *very* expensive; only
+                                 * do it if failed >= 2
+                                 */
+                                int other;
+                                for (other = disks; other--; ) {
+                                        if (other == i)
+                                                continue;
+                                        if (!test_bit(R5_UPTODATE,
+                                              &sh->dev[other].flags))
+                                                break;
+                                }
+                                BUG_ON(other < 0);
+                                pr_debug("Computing stripe %llu blocks %d,%d\n",
+                                       (unsigned long long)sh->sector,
+                                       i, other);
+                                compute_block_2(sh, i, other);
+                                s->uptodate += 2;
+                        } else if (test_bit(R5_Insync, &dev->flags)) {
+                                set_bit(R5_LOCKED, &dev->flags);
+                                set_bit(R5_Wantread, &dev->flags);
+                                s->locked++;
+                                pr_debug("Reading block %d (sync=%d)\n",
+                                        i, s->syncing);
+                        }
+                }
+        }
+        set_bit(STRIPE_HANDLE, &sh->state);
+}
+
+
+/* handle_completed_write_requests
+ * any written block on an uptodate or failed drive can be returned.
+ * Note that if we 'wrote' to a failed drive, it will be UPTODATE, but
+ * never LOCKED, so we don't need to test 'failed' directly.
+ */
+static void handle_completed_write_requests(raid5_conf_t *conf,
+        struct stripe_head *sh, int disks, struct bio **return_bi)
+{
+        int i;
+        struct r5dev *dev;
+
+        for (i = disks; i--; )
+                if (sh->dev[i].written) {
+                        dev = &sh->dev[i];
+                        if (!test_bit(R5_LOCKED, &dev->flags) &&
+                                test_bit(R5_UPTODATE, &dev->flags)) {
+                                /* We can return any write requests */
+                                struct bio *wbi, *wbi2;
+                                int bitmap_end = 0;
+                                pr_debug("Return write for disc %d\n", i);
+                                spin_lock_irq(&conf->device_lock);
+                                wbi = dev->written;
+                                dev->written = NULL;
+                                while (wbi && wbi->bi_sector <
+                                        dev->sector + STRIPE_SECTORS) {
+                                        wbi2 = r5_next_bio(wbi, dev->sector);
+                                        if (--wbi->bi_phys_segments == 0) {
+                                                md_write_end(conf->mddev);
+                                                wbi->bi_next = *return_bi;
+                                                *return_bi = wbi;
+                                        }
+                                        wbi = wbi2;
+                                }
+                                if (dev->towrite == NULL)
+                                        bitmap_end = 1;
+                                spin_unlock_irq(&conf->device_lock);
+                                if (bitmap_end)
+                                        bitmap_endwrite(conf->mddev->bitmap,
+                                                        sh->sector,
+                                                        STRIPE_SECTORS,
+                                         !test_bit(STRIPE_DEGRADED, &sh->state),
+                                                        0);
+                        }
+                }
+}
+
+static void handle_issuing_new_write_requests5(raid5_conf_t *conf,
+                struct stripe_head *sh, struct stripe_head_state *s, int disks)
+{
+        int rmw = 0, rcw = 0, i;
+        for (i = disks; i--; ) {
+                /* would I have to read this buffer for read_modify_write */
+                struct r5dev *dev = &sh->dev[i];
+                if ((dev->towrite || i == sh->pd_idx) &&
+                    !test_bit(R5_LOCKED, &dev->flags) &&
+                    !(test_bit(R5_UPTODATE, &dev->flags) ||
+                      test_bit(R5_Wantcompute, &dev->flags))) {
+                        if (test_bit(R5_Insync, &dev->flags))
+                                rmw++;
+                        else
+                                rmw += 2*disks;  /* cannot read it */
+                }
+                /* Would I have to read this buffer for reconstruct_write */
+                if (!test_bit(R5_OVERWRITE, &dev->flags) && i != sh->pd_idx &&
+                    !test_bit(R5_LOCKED, &dev->flags) &&
+                    !(test_bit(R5_UPTODATE, &dev->flags) ||
+                    test_bit(R5_Wantcompute, &dev->flags))) {
+                        if (test_bit(R5_Insync, &dev->flags)) rcw++;
+                        else
+                                rcw += 2*disks;
+                }
+        }
+        pr_debug("for sector %llu, rmw=%d rcw=%d\n",
+                (unsigned long long)sh->sector, rmw, rcw);
+        set_bit(STRIPE_HANDLE, &sh->state);
+        if (rmw < rcw && rmw > 0)
+                /* prefer read-modify-write, but need to get some data */
+                for (i = disks; i--; ) {
+                        struct r5dev *dev = &sh->dev[i];
+                        if ((dev->towrite || i == sh->pd_idx) &&
+                            !test_bit(R5_LOCKED, &dev->flags) &&
+                            !(test_bit(R5_UPTODATE, &dev->flags) ||
+                            test_bit(R5_Wantcompute, &dev->flags)) &&
+                            test_bit(R5_Insync, &dev->flags)) {
+                                if (
+                                  test_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
+                                        pr_debug("Read_old block "
+                                                "%d for r-m-w\n", i);
+                                        set_bit(R5_LOCKED, &dev->flags);
+                                        set_bit(R5_Wantread, &dev->flags);
+                                        if (!test_and_set_bit(
+                                                STRIPE_OP_IO, &sh->ops.pending))
+                                                sh->ops.count++;
+                                        s->locked++;
+                                } else {
+                                        set_bit(STRIPE_DELAYED, &sh->state);
+                                        set_bit(STRIPE_HANDLE, &sh->state);
+                                }
+                        }
+                }
+        if (rcw <= rmw && rcw > 0)
+                /* want reconstruct write, but need to get some data */
+                for (i = disks; i--; ) {
+                        struct r5dev *dev = &sh->dev[i];
+                        if (!test_bit(R5_OVERWRITE, &dev->flags) &&
+                            i != sh->pd_idx &&
+                            !test_bit(R5_LOCKED, &dev->flags) &&
+                            !(test_bit(R5_UPTODATE, &dev->flags) ||
+                            test_bit(R5_Wantcompute, &dev->flags)) &&
+                            test_bit(R5_Insync, &dev->flags)) {
+                                if (
+                                  test_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
+                                        pr_debug("Read_old block "
+                                                "%d for Reconstruct\n", i);
+                                        set_bit(R5_LOCKED, &dev->flags);
+                                        set_bit(R5_Wantread, &dev->flags);
+                                        if (!test_and_set_bit(
+                                                STRIPE_OP_IO, &sh->ops.pending))
+                                                sh->ops.count++;
+                                        s->locked++;
+                                } else {
+                                        set_bit(STRIPE_DELAYED, &sh->state);
+                                        set_bit(STRIPE_HANDLE, &sh->state);
+                                }
+                        }
+                }
+        /* now if nothing is locked, and if we have enough data,
+         * we can start a write request
+         */
+        /* since handle_stripe can be called at any time we need to handle the
+         * case where a compute block operation has been submitted and then a
+         * subsequent call wants to start a write request.  raid5_run_ops only
+         * handles the case where compute block and postxor are requested
+         * simultaneously.  If this is not the case then new writes need to be
+         * held off until the compute completes.
+         */
+        if ((s->req_compute ||
+            !test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending)) &&
+                (s->locked == 0 && (rcw == 0 || rmw == 0) &&
+                !test_bit(STRIPE_BIT_DELAY, &sh->state)))
+                s->locked += handle_write_operations5(sh, rcw == 0, 0);
+}
+
+static void handle_issuing_new_write_requests6(raid5_conf_t *conf,
+                struct stripe_head *sh, struct stripe_head_state *s,
+                struct r6_state *r6s, int disks)
+{
+        int rcw = 0, must_compute = 0, pd_idx = sh->pd_idx, i;
+        int qd_idx = r6s->qd_idx;
+        for (i = disks; i--; ) {
+                struct r5dev *dev = &sh->dev[i];
+                /* Would I have to read this buffer for reconstruct_write */
+                if (!test_bit(R5_OVERWRITE, &dev->flags)
+                    && i != pd_idx && i != qd_idx
+                    && (!test_bit(R5_LOCKED, &dev->flags)
+                            ) &&
+                    !test_bit(R5_UPTODATE, &dev->flags)) {
+                        if (test_bit(R5_Insync, &dev->flags)) rcw++;
+                        else {
+                                pr_debug("raid6: must_compute: "
+                                        "disk %d flags=%#lx\n", i, dev->flags);
+                                must_compute++;
+                        }
+                }
+        }
+        pr_debug("for sector %llu, rcw=%d, must_compute=%d\n",
+               (unsigned long long)sh->sector, rcw, must_compute);
+        set_bit(STRIPE_HANDLE, &sh->state);
+
+        if (rcw > 0)
+                /* want reconstruct write, but need to get some data */
+                for (i = disks; i--; ) {
+                        struct r5dev *dev = &sh->dev[i];
+                        if (!test_bit(R5_OVERWRITE, &dev->flags)
+                            && !(s->failed == 0 && (i == pd_idx || i == qd_idx))
+                            && !test_bit(R5_LOCKED, &dev->flags) &&
+                            !test_bit(R5_UPTODATE, &dev->flags) &&
+                            test_bit(R5_Insync, &dev->flags)) {
+                                if (
+                                  test_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
+                                        pr_debug("Read_old stripe %llu "
+                                                "block %d for Reconstruct\n",
+                                             (unsigned long long)sh->sector, i);
+                                        set_bit(R5_LOCKED, &dev->flags);
+                                        set_bit(R5_Wantread, &dev->flags);
+                                        s->locked++;
+                                } else {
+                                        pr_debug("Request delayed stripe %llu "
+                                                "block %d for Reconstruct\n",
+                                             (unsigned long long)sh->sector, i);
+                                        set_bit(STRIPE_DELAYED, &sh->state);
+                                        set_bit(STRIPE_HANDLE, &sh->state);
+                                }
+                        }
+                }
+        /* now if nothing is locked, and if we have enough data, we can start a
+         * write request
+         */
+        if (s->locked == 0 && rcw == 0 &&
+            !test_bit(STRIPE_BIT_DELAY, &sh->state)) {
+                if (must_compute > 0) {
+                        /* We have failed blocks and need to compute them */
+                        switch (s->failed) {
+                        case 0:
+                                BUG();
+                        case 1:
+                                compute_block_1(sh, r6s->failed_num[0], 0);
+                                break;
+                        case 2:
+                                compute_block_2(sh, r6s->failed_num[0],
+                                                r6s->failed_num[1]);
+                                break;
+                        default: /* This request should have been failed? */
+                                BUG();
+                        }
+                }
+
+                pr_debug("Computing parity for stripe %llu\n",
+                        (unsigned long long)sh->sector);
+                compute_parity6(sh, RECONSTRUCT_WRITE);
+                /* now every locked buffer is ready to be written */
+                for (i = disks; i--; )
+                        if (test_bit(R5_LOCKED, &sh->dev[i].flags)) {
+                                pr_debug("Writing stripe %llu block %d\n",
+                                       (unsigned long long)sh->sector, i);
+                                s->locked++;
+                                set_bit(R5_Wantwrite, &sh->dev[i].flags);
+                        }
+                /* after a RECONSTRUCT_WRITE, the stripe MUST be in-sync */
+                set_bit(STRIPE_INSYNC, &sh->state);
+
+                if (test_and_clear_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
+                        atomic_dec(&conf->preread_active_stripes);
+                        if (atomic_read(&conf->preread_active_stripes) <
+                            IO_THRESHOLD)
+                                md_wakeup_thread(conf->mddev->thread);
+                }
+        }
+}
+
+static void handle_parity_checks5(raid5_conf_t *conf, struct stripe_head *sh,
+                                struct stripe_head_state *s, int disks)
+{
+        set_bit(STRIPE_HANDLE, &sh->state);
+        /* Take one of the following actions:
+         * 1/ start a check parity operation if (uptodate == disks)
+         * 2/ finish a check parity operation and act on the result
+         * 3/ skip to the writeback section if we previously
+         *    initiated a recovery operation
+         */
+        if (s->failed == 0 &&
+            !test_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending)) {
+                if (!test_and_set_bit(STRIPE_OP_CHECK, &sh->ops.pending)) {
+                        BUG_ON(s->uptodate != disks);
+                        clear_bit(R5_UPTODATE, &sh->dev[sh->pd_idx].flags);
+                        sh->ops.count++;
+                        s->uptodate--;
+                } else if (
+                       test_and_clear_bit(STRIPE_OP_CHECK, &sh->ops.complete)) {
+                        clear_bit(STRIPE_OP_CHECK, &sh->ops.ack);
+                        clear_bit(STRIPE_OP_CHECK, &sh->ops.pending);
+
+                        if (sh->ops.zero_sum_result == 0)
+                                /* parity is correct (on disc,
+                                 * not in buffer any more)
+                                 */
+                                set_bit(STRIPE_INSYNC, &sh->state);
+                        else {
+                                conf->mddev->resync_mismatches +=
+                                        STRIPE_SECTORS;
+                                if (test_bit(
+                                     MD_RECOVERY_CHECK, &conf->mddev->recovery))
+                                        /* don't try to repair!! */
+                                        set_bit(STRIPE_INSYNC, &sh->state);
+                                else {
+                                        set_bit(STRIPE_OP_COMPUTE_BLK,
+                                                &sh->ops.pending);
+                                        set_bit(STRIPE_OP_MOD_REPAIR_PD,
+                                                &sh->ops.pending);
+                                        set_bit(R5_Wantcompute,
+                                                &sh->dev[sh->pd_idx].flags);
+                                        sh->ops.target = sh->pd_idx;
+                                        sh->ops.count++;
+                                        s->uptodate++;
+                                }
+                        }
+                }
+        }
+
+        /* check if we can clear a parity disk reconstruct */
+        if (test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete) &&
+                test_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending)) {
+
+                clear_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending);
+                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.complete);
+                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.ack);
+                clear_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending);
+        }
+
+        /* Wait for check parity and compute block operations to complete
+         * before write-back
+         */
+        if (!test_bit(STRIPE_INSYNC, &sh->state) &&
+                !test_bit(STRIPE_OP_CHECK, &sh->ops.pending) &&
+                !test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending)) {
+                struct r5dev *dev;
+                /* either failed parity check, or recovery is happening */
+                if (s->failed == 0)
+                        s->failed_num = sh->pd_idx;
+                dev = &sh->dev[s->failed_num];
+                BUG_ON(!test_bit(R5_UPTODATE, &dev->flags));
+                BUG_ON(s->uptodate != disks);
+
+                set_bit(R5_LOCKED, &dev->flags);
+                set_bit(R5_Wantwrite, &dev->flags);
+                if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
+                        sh->ops.count++;
+
+                clear_bit(STRIPE_DEGRADED, &sh->state);
+                s->locked++;
+                set_bit(STRIPE_INSYNC, &sh->state);
+        }
+}
+
+
+static void handle_parity_checks6(raid5_conf_t *conf, struct stripe_head *sh,
+                                struct stripe_head_state *s,
+                                struct r6_state *r6s, struct page *tmp_page,
+                                int disks)
+{
+        int update_p = 0, update_q = 0;
+        struct r5dev *dev;
+        int pd_idx = sh->pd_idx;
+        int qd_idx = r6s->qd_idx;
+
+        set_bit(STRIPE_HANDLE, &sh->state);
+
+        BUG_ON(s->failed > 2);
+        BUG_ON(s->uptodate < disks);
+        /* Want to check and possibly repair P and Q.
+         * However there could be one 'failed' device, in which
+         * case we can only check one of them, possibly using the
+         * other to generate missing data
+         */
+
+        /* If !tmp_page, we cannot do the calculations,
+         * but as we have set STRIPE_HANDLE, we will soon be called
+         * by stripe_handle with a tmp_page - just wait until then.
+         */
+        if (tmp_page) {
+                if (s->failed == r6s->q_failed) {
+                        /* The only possible failed device holds 'Q', so it
+                         * makes sense to check P (If anything else were failed,
+                         * we would have used P to recreate it).
+                         */
+                        compute_block_1(sh, pd_idx, 1);
+                        if (!page_is_zero(sh->dev[pd_idx].page)) {
+                                compute_block_1(sh, pd_idx, 0);
+                                update_p = 1;
+                        }
+                }
+                if (!r6s->q_failed && s->failed < 2) {
+                        /* q is not failed, and we didn't use it to generate
+                         * anything, so it makes sense to check it
+                         */
+                        memcpy(page_address(tmp_page),
+                               page_address(sh->dev[qd_idx].page),
+                               STRIPE_SIZE);
+                        compute_parity6(sh, UPDATE_PARITY);
+                        if (memcmp(page_address(tmp_page),
+                                   page_address(sh->dev[qd_idx].page),
+                                   STRIPE_SIZE) != 0) {
+                                clear_bit(STRIPE_INSYNC, &sh->state);
+                                update_q = 1;
+                        }
+                }
+                if (update_p || update_q) {
+                        conf->mddev->resync_mismatches += STRIPE_SECTORS;
+                        if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery))
+                                /* don't try to repair!! */
+                                update_p = update_q = 0;
+                }
+
+                /* now write out any block on a failed drive,
+                 * or P or Q if they need it
+                 */
+
+                if (s->failed == 2) {
+                        dev = &sh->dev[r6s->failed_num[1]];
+                        s->locked++;
+                        set_bit(R5_LOCKED, &dev->flags);
+                        set_bit(R5_Wantwrite, &dev->flags);
+                }
+                if (s->failed >= 1) {
+                        dev = &sh->dev[r6s->failed_num[0]];
+                        s->locked++;
+                        set_bit(R5_LOCKED, &dev->flags);
+                        set_bit(R5_Wantwrite, &dev->flags);
+                }
+
+                if (update_p) {
+                        dev = &sh->dev[pd_idx];
+                        s->locked++;
+                        set_bit(R5_LOCKED, &dev->flags);
+                        set_bit(R5_Wantwrite, &dev->flags);
+                }
+                if (update_q) {
+                        dev = &sh->dev[qd_idx];
+                        s->locked++;
+                        set_bit(R5_LOCKED, &dev->flags);
+                        set_bit(R5_Wantwrite, &dev->flags);
+                }
+                clear_bit(STRIPE_DEGRADED, &sh->state);
+
+                set_bit(STRIPE_INSYNC, &sh->state);
+        }
+}
+
+static void handle_stripe_expansion(raid5_conf_t *conf, struct stripe_head *sh,
+                                struct r6_state *r6s)
+{
+        int i;
+
+        /* We have read all the blocks in this stripe and now we need to
+         * copy some of them into a target stripe for expand.
+         */
+        struct dma_async_tx_descriptor *tx = NULL;
+        clear_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+        for (i = 0; i < sh->disks; i++)
+                if (i != sh->pd_idx && (r6s && i != r6s->qd_idx)) {
+                        int dd_idx, pd_idx, j;
+                        struct stripe_head *sh2;
+
+                        sector_t bn = compute_blocknr(sh, i);
+                        sector_t s = raid5_compute_sector(bn, conf->raid_disks,
+                                                conf->raid_disks -
+                                                conf->max_degraded, &dd_idx,
+                                                &pd_idx, conf);
+                        sh2 = get_active_stripe(conf, s, conf->raid_disks,
+                                                pd_idx, 1);
+                        if (sh2 == NULL)
+                                /* so far only the early blocks of this stripe
+                                 * have been requested.  When later blocks
+                                 * get requested, we will try again
+                                 */
+                                continue;
+                        if (!test_bit(STRIPE_EXPANDING, &sh2->state) ||
+                           test_bit(R5_Expanded, &sh2->dev[dd_idx].flags)) {
+                                /* must have already done this block */
+                                release_stripe(sh2);
+                                continue;
+                        }
+
+                        /* place all the copies on one channel */
+                        tx = async_memcpy(sh2->dev[dd_idx].page,
+                                sh->dev[i].page, 0, 0, STRIPE_SIZE,
+                                ASYNC_TX_DEP_ACK, tx, NULL, NULL);
+
+                        set_bit(R5_Expanded, &sh2->dev[dd_idx].flags);
+                        set_bit(R5_UPTODATE, &sh2->dev[dd_idx].flags);
+                        for (j = 0; j < conf->raid_disks; j++)
+                                if (j != sh2->pd_idx &&
+                                    (r6s && j != r6s->qd_idx) &&
+                                    !test_bit(R5_Expanded, &sh2->dev[j].flags))
+                                        break;
+                        if (j == conf->raid_disks) {
+                                set_bit(STRIPE_EXPAND_READY, &sh2->state);
+                                set_bit(STRIPE_HANDLE, &sh2->state);
+                        }
+                        release_stripe(sh2);
+
+                        /* done submitting copies, wait for them to complete */
+                        if (i + 1 >= sh->disks) {
+                                async_tx_ack(tx);
+                                dma_wait_for_async_tx(tx);
+                        }
+                }
+}
 
 /*
  * handle_stripe - do things to a stripe.
@@ -1339,81 +2603,70 @@ static int stripe_to_pdidx(sector_t stripe, raid5_conf_t *conf, int disks)
  *    schedule a write of some buffers
  *    return confirmation of parity correctness
  *
- * Parity calculations are done inside the stripe lock
  * buffers are taken off read_list or write_list, and bh_cache buffers
  * get BH_Lock set before the stripe lock is released.
  *
  */
- 
+
 static void handle_stripe5(struct stripe_head *sh)
 {
         raid5_conf_t *conf = sh->raid_conf;
-        int disks = sh->disks;
-        struct bio *return_bi= NULL;
-        struct bio *bi;
-        int i;
-        int syncing, expanding, expanded;
-        int locked=0, uptodate=0, to_read=0, to_write=0, failed=0, written=0;
-        int non_overwrite = 0;
-        int failed_num=0;
+        int disks = sh->disks, i;
+        struct bio *return_bi = NULL;
+        struct stripe_head_state s;
         struct r5dev *dev;
+        unsigned long pending = 0;
 
-        PRINTK("handling stripe %llu, cnt=%d, pd_idx=%d\n",
-                (unsigned long long)sh->sector, atomic_read(&sh->count),
-                sh->pd_idx);
+        memset(&s, 0, sizeof(s));
+        pr_debug("handling stripe %llu, state=%#lx cnt=%d, pd_idx=%d "
+                "ops=%lx:%lx:%lx\n", (unsigned long long)sh->sector, sh->state,
+                atomic_read(&sh->count), sh->pd_idx,
+                sh->ops.pending, sh->ops.ack, sh->ops.complete);
 
         spin_lock(&sh->lock);
         clear_bit(STRIPE_HANDLE, &sh->state);
         clear_bit(STRIPE_DELAYED, &sh->state);
 
-        syncing = test_bit(STRIPE_SYNCING, &sh->state);
-        expanding = test_bit(STRIPE_EXPAND_SOURCE, &sh->state);
-        expanded = test_bit(STRIPE_EXPAND_READY, &sh->state);
+        s.syncing = test_bit(STRIPE_SYNCING, &sh->state);
+        s.expanding = test_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+        s.expanded = test_bit(STRIPE_EXPAND_READY, &sh->state);
         /* Now to look around and see what can be done */
 
         rcu_read_lock();
         for (i=disks; i--; ) {
                 mdk_rdev_t *rdev;
-                dev = &sh->dev[i];
+                struct r5dev *dev = &sh->dev[i];
                 clear_bit(R5_Insync, &dev->flags);
 
-                PRINTK("check %d: state 0x%lx read %p write %p written %p\n",
-                        i, dev->flags, dev->toread, dev->towrite, dev->written);
-                /* maybe we can reply to a read */
-                if (test_bit(R5_UPTODATE, &dev->flags) && dev->toread) {
-                        struct bio *rbi, *rbi2;
-                        PRINTK("Return read for disc %d\n", i);
-                        spin_lock_irq(&conf->device_lock);
-                        rbi = dev->toread;
-                        dev->toread = NULL;
-                        if (test_and_clear_bit(R5_Overlap, &dev->flags))
-                                wake_up(&conf->wait_for_overlap);
-                        spin_unlock_irq(&conf->device_lock);
-                        while (rbi && rbi->bi_sector < dev->sector + STRIPE_SECTORS) {
-                                copy_data(0, rbi, dev->page, dev->sector);
-                                rbi2 = r5_next_bio(rbi, dev->sector);
-                                spin_lock_irq(&conf->device_lock);
-                                if (--rbi->bi_phys_segments == 0) {
-                                        rbi->bi_next = return_bi;
-                                        return_bi = rbi;
-                                }
-                                spin_unlock_irq(&conf->device_lock);
-                                rbi = rbi2;
-                        }
-                }
+                pr_debug("check %d: state 0x%lx toread %p read %p write %p "
+                        "written %p\n", i, dev->flags, dev->toread, dev->read,
+                        dev->towrite, dev->written);
 
-                /* now count some things */
-                if (test_bit(R5_LOCKED, &dev->flags)) locked++;
-                if (test_bit(R5_UPTODATE, &dev->flags)) uptodate++;
+                /* maybe we can request a biofill operation
+                 *
+                 * new wantfill requests are only permitted while
+                 * STRIPE_OP_BIOFILL is clear
+                 */
+                if (test_bit(R5_UPTODATE, &dev->flags) && dev->toread &&
+                        !test_bit(STRIPE_OP_BIOFILL, &sh->ops.pending))
+                        set_bit(R5_Wantfill, &dev->flags);
 
-                
-                if (dev->toread) to_read++;
+                /* now count some things */
+                if (test_bit(R5_LOCKED, &dev->flags)) s.locked++;
+                if (test_bit(R5_UPTODATE, &dev->flags)) s.uptodate++;
+                if (test_bit(R5_Wantcompute, &dev->flags)) s.compute++;
+
+                if (test_bit(R5_Wantfill, &dev->flags))
+                        s.to_fill++;
+                else if (dev->toread)
+                        s.to_read++;
                 if (dev->towrite) {
-                        to_write++;
+                        s.to_write++;
                         if (!test_bit(R5_OVERWRITE, &dev->flags))
-                                non_overwrite++;
+                                s.non_overwrite++;
                 }
-                if (dev->written) written++;
+                if (dev->written)
+                        s.written++;
                 rdev = rcu_dereference(conf->disks[i].rdev);
                 if (!rdev || !test_bit(In_sync, &rdev->flags)) {
                         /* The ReadError flag will just be confusing now */
@@ -1422,306 +2675,131 @@ static void handle_stripe5(struct stripe_head *sh)
                 }
                 if (!rdev || !test_bit(In_sync, &rdev->flags)
                     || test_bit(R5_ReadError, &dev->flags)) {
-                        failed++;
-                        failed_num = i;
+                        s.failed++;
+                        s.failed_num = i;
                 } else
                         set_bit(R5_Insync, &dev->flags);
         }
         rcu_read_unlock();
-        PRINTK("locked=%d uptodate=%d to_read=%d"
+
+        if (s.to_fill && !test_and_set_bit(STRIPE_OP_BIOFILL, &sh->ops.pending))
+                sh->ops.count++;
+
+        pr_debug("locked=%d uptodate=%d to_read=%d"
                 " to_write=%d failed=%d failed_num=%d\n",
-                locked, uptodate, to_read, to_write, failed, failed_num);
+                s.locked, s.uptodate, s.to_read, s.to_write,
+                s.failed, s.failed_num);
         /* check if the array has lost two devices and, if so, some requests might
          * need to be failed
          */
-        if (failed > 1 && to_read+to_write+written) {
-                for (i=disks; i--; ) {
-                        int bitmap_end = 0;
-
-                        if (test_bit(R5_ReadError, &sh->dev[i].flags)) {
-                                mdk_rdev_t *rdev;
-                                rcu_read_lock();
-                                rdev = rcu_dereference(conf->disks[i].rdev);
-                                if (rdev && test_bit(In_sync, &rdev->flags))
-                                        /* multiple read failures in one stripe */
-                                        md_error(conf->mddev, rdev);
-                                rcu_read_unlock();
-                        }
-
-                        spin_lock_irq(&conf->device_lock);
-                        /* fail all writes first */
-                        bi = sh->dev[i].towrite;
-                        sh->dev[i].towrite = NULL;
-                        if (bi) { to_write--; bitmap_end = 1; }
-
-                        if (test_and_clear_bit(R5_Overlap, &sh->dev[i].flags))
-                                wake_up(&conf->wait_for_overlap);
-
-                        while (bi && bi->bi_sector < sh->dev[i].sector + STRIPE_SECTORS){
-                                struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);
-                                clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                                if (--bi->bi_phys_segments == 0) {
-                                        md_write_end(conf->mddev);
-                                        bi->bi_next = return_bi;
-                                        return_bi = bi;
-                                }
-                                bi = nextbi;
-                        }
-                        /* and fail all 'written' */
-                        bi = sh->dev[i].written;
-                        sh->dev[i].written = NULL;
-                        if (bi) bitmap_end = 1;
-                        while (bi && bi->bi_sector < sh->dev[i].sector + STRIPE_SECTORS) {
-                                struct bio *bi2 = r5_next_bio(bi, sh->dev[i].sector);
-                                clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                                if (--bi->bi_phys_segments == 0) {
-                                        md_write_end(conf->mddev);
-                                        bi->bi_next = return_bi;
-                                        return_bi = bi;
-                                }
-                                bi = bi2;
-                        }
-
-                        /* fail any reads if this device is non-operational */
-                        if (!test_bit(R5_Insync, &sh->dev[i].flags) ||
-                            test_bit(R5_ReadError, &sh->dev[i].flags)) {
-                                bi = sh->dev[i].toread;
-                                sh->dev[i].toread = NULL;
-                                if (test_and_clear_bit(R5_Overlap, &sh->dev[i].flags))
-                                        wake_up(&conf->wait_for_overlap);
-                                if (bi) to_read--;
-                                while (bi && bi->bi_sector < sh->dev[i].sector + STRIPE_SECTORS){
-                                        struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);
-                                        clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                                        if (--bi->bi_phys_segments == 0) {
-                                                bi->bi_next = return_bi;
-                                                return_bi = bi;
-                                        }
-                                        bi = nextbi;
-                                }
-                        }
-                        spin_unlock_irq(&conf->device_lock);
-                        if (bitmap_end)
-                                bitmap_endwrite(conf->mddev->bitmap, sh->sector,
-                                                STRIPE_SECTORS, 0, 0);
-                }
-        }
-        if (failed > 1 && syncing) {
+        if (s.failed > 1 && s.to_read+s.to_write+s.written)
+                handle_requests_to_failed_array(conf, sh, &s, disks,
+                                                &return_bi);
+        if (s.failed > 1 && s.syncing) {
                 md_done_sync(conf->mddev, STRIPE_SECTORS,0);
                 clear_bit(STRIPE_SYNCING, &sh->state);
-                syncing = 0;
+                s.syncing = 0;
         }
 
         /* might be able to return some write requests if the parity block
          * is safe, or on a failed drive
          */
         dev = &sh->dev[sh->pd_idx];
-        if ( written &&
-             ( (test_bit(R5_Insync, &dev->flags) && !test_bit(R5_LOCKED, &dev->flags) &&
-                test_bit(R5_UPTODATE, &dev->flags))
-               || (failed == 1 && failed_num == sh->pd_idx))
-            ) {
-            /* any written block on an uptodate or failed drive can be returned.
-             * Note that if we 'wrote' to a failed drive, it will be UPTODATE, but 
-             * never LOCKED, so we don't need to test 'failed' directly.
-             */
-            for (i=disks; i--; )
-                if (sh->dev[i].written) {
-                    dev = &sh->dev[i];
-                    if (!test_bit(R5_LOCKED, &dev->flags) &&
-                         test_bit(R5_UPTODATE, &dev->flags) ) {
-                        /* We can return any write requests */
-                            struct bio *wbi, *wbi2;
-                            int bitmap_end = 0;
-                            PRINTK("Return write for disc %d\n", i);
-                            spin_lock_irq(&conf->device_lock);
-                            wbi = dev->written;
-                            dev->written = NULL;
-                            while (wbi && wbi->bi_sector < dev->sector + STRIPE_SECTORS) {
-                                    wbi2 = r5_next_bio(wbi, dev->sector);
-                                    if (--wbi->bi_phys_segments == 0) {
-                                            md_write_end(conf->mddev);
-                                            wbi->bi_next = return_bi;
-                                            return_bi = wbi;
-                                    }
-                                    wbi = wbi2;
-                            }
-                            if (dev->towrite == NULL)
-                                    bitmap_end = 1;
-                            spin_unlock_irq(&conf->device_lock);
-                            if (bitmap_end)
-                                    bitmap_endwrite(conf->mddev->bitmap, sh->sector,
-                                                    STRIPE_SECTORS,
-                                                    !test_bit(STRIPE_DEGRADED, &sh->state), 0);
-                    }
-                }
-        }
+        if ( s.written &&
+             ((test_bit(R5_Insync, &dev->flags) &&
+               !test_bit(R5_LOCKED, &dev->flags) &&
+               test_bit(R5_UPTODATE, &dev->flags)) ||
+               (s.failed == 1 && s.failed_num == sh->pd_idx)))
+                handle_completed_write_requests(conf, sh, disks, &return_bi);
 
         /* Now we might consider reading some blocks, either to check/generate
          * parity, or to satisfy requests
          * or to load a block that is being partially written.
          */
-        if (to_read || non_overwrite || (syncing && (uptodate < disks)) || expanding) {
-                for (i=disks; i--;) {
-                        dev = &sh->dev[i];
-                        if (!test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) &&
-                            (dev->toread ||
-                             (dev->towrite && !test_bit(R5_OVERWRITE, &dev->flags)) ||
-                             syncing ||
-                             expanding ||
-                             (failed && (sh->dev[failed_num].toread ||
-                                         (sh->dev[failed_num].towrite && !test_bit(R5_OVERWRITE, &sh->dev[failed_num].flags))))
-                                    )
-                                ) {
-                                /* we would like to get this block, possibly
-                                 * by computing it, but we might not be able to
-                                 */
-                                if (uptodate == disks-1) {
-                                        PRINTK("Computing block %d\n", i);
-                                        compute_block(sh, i);
-                                        uptodate++;
-                                } else if (test_bit(R5_Insync, &dev->flags)) {
-                                        set_bit(R5_LOCKED, &dev->flags);
-                                        set_bit(R5_Wantread, &dev->flags);
-                                        locked++;
-                                        PRINTK("Reading block %d (sync=%d)\n", 
-                                                i, syncing);
-                                }
-                        }
-                }
-                set_bit(STRIPE_HANDLE, &sh->state);
+        if (s.to_read || s.non_overwrite ||
+            (s.syncing && (s.uptodate + s.compute < disks)) || s.expanding ||
+            test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending))
+                handle_issuing_new_read_requests5(sh, &s, disks);
+
+        /* Now we check to see if any write operations have recently
+         * completed
+         */
+
+        /* leave prexor set until postxor is done, allows us to distinguish
+         * a rmw from a rcw during biodrain
+         */
+        if (test_bit(STRIPE_OP_PREXOR, &sh->ops.complete) &&
+                test_bit(STRIPE_OP_POSTXOR, &sh->ops.complete)) {
+
+                clear_bit(STRIPE_OP_PREXOR, &sh->ops.complete);
+                clear_bit(STRIPE_OP_PREXOR, &sh->ops.ack);
+                clear_bit(STRIPE_OP_PREXOR, &sh->ops.pending);
+
+                for (i = disks; i--; )
+                        clear_bit(R5_Wantprexor, &sh->dev[i].flags);
         }
 
-        /* now to consider writing and what else, if anything should be read */
-        if (to_write) {
-                int rmw=0, rcw=0;
-                for (i=disks ; i--;) {
-                        /* would I have to read this buffer for read_modify_write */
+        /* if only POSTXOR is set then this is an 'expand' postxor */
+        if (test_bit(STRIPE_OP_BIODRAIN, &sh->ops.complete) &&
+                test_bit(STRIPE_OP_POSTXOR, &sh->ops.complete)) {
+
+                clear_bit(STRIPE_OP_BIODRAIN, &sh->ops.complete);
+                clear_bit(STRIPE_OP_BIODRAIN, &sh->ops.ack);
+                clear_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending);
+
+                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.complete);
+                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.ack);
+                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.pending);
+
+                /* All the 'written' buffers and the parity block are ready to
+                 * be written back to disk
+                 */
+                BUG_ON(!test_bit(R5_UPTODATE, &sh->dev[sh->pd_idx].flags));
+                for (i = disks; i--; ) {
                         dev = &sh->dev[i];
-                        if ((dev->towrite || i == sh->pd_idx) &&
-                            (!test_bit(R5_LOCKED, &dev->flags) 
-                                    ) &&
-                            !test_bit(R5_UPTODATE, &dev->flags)) {
-                                if (test_bit(R5_Insync, &dev->flags)
-/*                                  && !(!mddev->insync && i == sh->pd_idx) */
-                                        )
-                                        rmw++;
-                                else rmw += 2*disks;  /* cannot read it */
-                        }
-                        /* Would I have to read this buffer for reconstruct_write */
-                        if (!test_bit(R5_OVERWRITE, &dev->flags) && i != sh->pd_idx &&
-                            (!test_bit(R5_LOCKED, &dev->flags) 
-                                    ) &&
-                            !test_bit(R5_UPTODATE, &dev->flags)) {
-                                if (test_bit(R5_Insync, &dev->flags)) rcw++;
-                                else rcw += 2*disks;
+                        if (test_bit(R5_LOCKED, &dev->flags) &&
+                                (i == sh->pd_idx || dev->written)) {
+                                pr_debug("Writing block %d\n", i);
+                                set_bit(R5_Wantwrite, &dev->flags);
+                                if (!test_and_set_bit(
+                                    STRIPE_OP_IO, &sh->ops.pending))
+                                        sh->ops.count++;
+                                if (!test_bit(R5_Insync, &dev->flags) ||
+                                    (i == sh->pd_idx && s.failed == 0))
+                                        set_bit(STRIPE_INSYNC, &sh->state);
                         }
                 }
-                PRINTK("for sector %llu, rmw=%d rcw=%d\n", 
-                        (unsigned long long)sh->sector, rmw, rcw);
-                set_bit(STRIPE_HANDLE, &sh->state);
-                if (rmw < rcw && rmw > 0)
-                        /* prefer read-modify-write, but need to get some data */
-                        for (i=disks; i--;) {
-                                dev = &sh->dev[i];
-                                if ((dev->towrite || i == sh->pd_idx) &&
-                                    !test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) &&
-                                    test_bit(R5_Insync, &dev->flags)) {
-                                        if (test_bit(STRIPE_PREREAD_ACTIVE, &sh->state))
-                                        {
-                                                PRINTK("Read_old block %d for r-m-w\n", i);
-                                                set_bit(R5_LOCKED, &dev->flags);
-                                                set_bit(R5_Wantread, &dev->flags);
-                                                locked++;
-                                        } else {
-                                                set_bit(STRIPE_DELAYED, &sh->state);
-                                                set_bit(STRIPE_HANDLE, &sh->state);
-                                        }
-                                }
-                        }
-                if (rcw <= rmw && rcw > 0)
-                        /* want reconstruct write, but need to get some data */
-                        for (i=disks; i--;) {
-                                dev = &sh->dev[i];
-                                if (!test_bit(R5_OVERWRITE, &dev->flags) && i != sh->pd_idx &&
-                                    !test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) &&
-                                    test_bit(R5_Insync, &dev->flags)) {
-                                        if (test_bit(STRIPE_PREREAD_ACTIVE, &sh->state))
-                                        {
-                                                PRINTK("Read_old block %d for Reconstruct\n", i);
-                                                set_bit(R5_LOCKED, &dev->flags);
-                                                set_bit(R5_Wantread, &dev->flags);
-                                                locked++;
-                                        } else {
-                                                set_bit(STRIPE_DELAYED, &sh->state);
-                                                set_bit(STRIPE_HANDLE, &sh->state);
-                                        }
-                                }
-                        }
-                /* now if nothing is locked, and if we have enough data, we can start a write request */
-                if (locked == 0 && (rcw == 0 ||rmw == 0) &&
-                    !test_bit(STRIPE_BIT_DELAY, &sh->state)) {
-                        PRINTK("Computing parity...\n");
-                        compute_parity5(sh, rcw==0 ? RECONSTRUCT_WRITE : READ_MODIFY_WRITE);
-                        /* now every locked buffer is ready to be written */
-                        for (i=disks; i--;)
-                                if (test_bit(R5_LOCKED, &sh->dev[i].flags)) {
-                                        PRINTK("Writing block %d\n", i);
-                                        locked++;
-                                        set_bit(R5_Wantwrite, &sh->dev[i].flags);
-                                        if (!test_bit(R5_Insync, &sh->dev[i].flags)
-                                            || (i==sh->pd_idx && failed == 0))
-                                                set_bit(STRIPE_INSYNC, &sh->state);
-                                }
-                        if (test_and_clear_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
-                                atomic_dec(&conf->preread_active_stripes);
-                                if (atomic_read(&conf->preread_active_stripes) < IO_THRESHOLD)
-                                        md_wakeup_thread(conf->mddev->thread);
-                        }
+                if (test_and_clear_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
+                        atomic_dec(&conf->preread_active_stripes);
+                        if (atomic_read(&conf->preread_active_stripes) <
+                                IO_THRESHOLD)
+                                md_wakeup_thread(conf->mddev->thread);
                 }
         }
 
-        /* maybe we need to check and possibly fix the parity for this stripe
-         * Any reads will already have been scheduled, so we just see if enough data
-         * is available
+        /* Now to consider new write requests and what else, if anything
+         * should be read.  We do not handle new writes when:
+         * 1/ A 'write' operation (copy+xor) is already in flight.
+         * 2/ A 'check' operation is in flight, as it may clobber the parity
+         *    block.
          */
-        if (syncing && locked == 0 &&
-            !test_bit(STRIPE_INSYNC, &sh->state)) {
-                set_bit(STRIPE_HANDLE, &sh->state);
-                if (failed == 0) {
-                        BUG_ON(uptodate != disks);
-                        compute_parity5(sh, CHECK_PARITY);
-                        uptodate--;
-                        if (page_is_zero(sh->dev[sh->pd_idx].page)) {
-                                /* parity is correct (on disc, not in buffer any more) */
-                                set_bit(STRIPE_INSYNC, &sh->state);
-                        } else {
-                                conf->mddev->resync_mismatches += STRIPE_SECTORS;
-                                if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery))
-                                        /* don't try to repair!! */
-                                        set_bit(STRIPE_INSYNC, &sh->state);
-                                else {
-                                        compute_block(sh, sh->pd_idx);
-                                        uptodate++;
-                                }
-                        }
-                }
-                if (!test_bit(STRIPE_INSYNC, &sh->state)) {
-                        /* either failed parity check, or recovery is happening */
-                        if (failed==0)
-                                failed_num = sh->pd_idx;
-                        dev = &sh->dev[failed_num];
-                        BUG_ON(!test_bit(R5_UPTODATE, &dev->flags));
-                        BUG_ON(uptodate != disks);
+        if (s.to_write && !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending) &&
+                          !test_bit(STRIPE_OP_CHECK, &sh->ops.pending))
+                handle_issuing_new_write_requests5(conf, sh, &s, disks);
 
-                        set_bit(R5_LOCKED, &dev->flags);
-                        set_bit(R5_Wantwrite, &dev->flags);
-                        clear_bit(STRIPE_DEGRADED, &sh->state);
-                        locked++;
-                        set_bit(STRIPE_INSYNC, &sh->state);
-                }
-        }
-        if (syncing && locked == 0 && test_bit(STRIPE_INSYNC, &sh->state)) {
+        /* maybe we need to check and possibly fix the parity for this stripe
+         * Any reads will already have been scheduled, so we just see if enough
+         * data is available.  The parity check is held off while parity
+         * dependent operations are in flight.
+         */
+        if ((s.syncing && s.locked == 0 &&
+             !test_bit(STRIPE_OP_COMPUTE_BLK, &sh->ops.pending) &&
+             !test_bit(STRIPE_INSYNC, &sh->state)) ||
+              test_bit(STRIPE_OP_CHECK, &sh->ops.pending) ||
+              test_bit(STRIPE_OP_MOD_REPAIR_PD, &sh->ops.pending))
+                handle_parity_checks5(conf, sh, &s, disks);
+
+        if (s.syncing && s.locked == 0 && test_bit(STRIPE_INSYNC, &sh->state)) {
                 md_done_sync(conf->mddev, STRIPE_SECTORS,1);
                 clear_bit(STRIPE_SYNCING, &sh->state);
         }
@@ -1729,186 +2807,102 @@ static void handle_stripe5(struct stripe_head *sh)
         /* If the failed drive is just a ReadError, then we might need to progress
          * the repair/check process
          */
-        if (failed == 1 && ! conf->mddev->ro &&
-            test_bit(R5_ReadError, &sh->dev[failed_num].flags)
-            && !test_bit(R5_LOCKED, &sh->dev[failed_num].flags)
-            && test_bit(R5_UPTODATE, &sh->dev[failed_num].flags)
+        if (s.failed == 1 && !conf->mddev->ro &&
+            test_bit(R5_ReadError, &sh->dev[s.failed_num].flags)
+            && !test_bit(R5_LOCKED, &sh->dev[s.failed_num].flags)
+            && test_bit(R5_UPTODATE, &sh->dev[s.failed_num].flags)
                 ) {
-                dev = &sh->dev[failed_num];
+                dev = &sh->dev[s.failed_num];
                 if (!test_bit(R5_ReWrite, &dev->flags)) {
                         set_bit(R5_Wantwrite, &dev->flags);
+                        if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
+                                sh->ops.count++;
                         set_bit(R5_ReWrite, &dev->flags);
                         set_bit(R5_LOCKED, &dev->flags);
-                        locked++;
+                        s.locked++;
                 } else {
                         /* let's read it back */
                         set_bit(R5_Wantread, &dev->flags);
+                        if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
+                                sh->ops.count++;
                         set_bit(R5_LOCKED, &dev->flags);
-                        locked++;
+                        s.locked++;
                 }
         }
 
-        if (expanded && test_bit(STRIPE_EXPANDING, &sh->state)) {
-                /* Need to write out all blocks after computing parity */
-                sh->disks = conf->raid_disks;
-                sh->pd_idx = stripe_to_pdidx(sh->sector, conf, conf->raid_disks);
-                compute_parity5(sh, RECONSTRUCT_WRITE);
-                for (i= conf->raid_disks; i--;) {
-                        set_bit(R5_LOCKED, &sh->dev[i].flags);
-                        locked++;
+        /* Finish postxor operations initiated by the expansion
+         * process
+         */
+        if (test_bit(STRIPE_OP_POSTXOR, &sh->ops.complete) &&
+                !test_bit(STRIPE_OP_BIODRAIN, &sh->ops.pending)) {
+
+                clear_bit(STRIPE_EXPANDING, &sh->state);
+
+                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.pending);
+                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.ack);
+                clear_bit(STRIPE_OP_POSTXOR, &sh->ops.complete);
+
+                for (i = conf->raid_disks; i--; ) {
                         set_bit(R5_Wantwrite, &sh->dev[i].flags);
+                        if (!test_and_set_bit(STRIPE_OP_IO, &sh->ops.pending))
+                                sh->ops.count++;
                 }
-                clear_bit(STRIPE_EXPANDING, &sh->state);
-        } else if (expanded) {
+        }
+
+        if (s.expanded && test_bit(STRIPE_EXPANDING, &sh->state) &&
+                !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending)) {
+                /* Need to write out all blocks after computing parity */
+                sh->disks = conf->raid_disks;
+                sh->pd_idx = stripe_to_pdidx(sh->sector, conf,
+                        conf->raid_disks);
+                s.locked += handle_write_operations5(sh, 0, 1);
+        } else if (s.expanded &&
+                !test_bit(STRIPE_OP_POSTXOR, &sh->ops.pending)) {
                 clear_bit(STRIPE_EXPAND_READY, &sh->state);
                 atomic_dec(&conf->reshape_stripes);
                 wake_up(&conf->wait_for_overlap);
                 md_done_sync(conf->mddev, STRIPE_SECTORS, 1);
         }
 
-        if (expanding && locked == 0) {
-                /* We have read all the blocks in this stripe and now we need to
-                 * copy some of them into a target stripe for expand.
-                 */
-                clear_bit(STRIPE_EXPAND_SOURCE, &sh->state);
-                for (i=0; i< sh->disks; i++)
-                        if (i != sh->pd_idx) {
-                                int dd_idx, pd_idx, j;
-                                struct stripe_head *sh2;
-
-                                sector_t bn = compute_blocknr(sh, i);
-                                sector_t s = raid5_compute_sector(bn, conf->raid_disks,
-                                                                  conf->raid_disks-1,
-                                                                  &dd_idx, &pd_idx, conf);
-                                sh2 = get_active_stripe(conf, s, conf->raid_disks, pd_idx, 1);
-                                if (sh2 == NULL)
-                                        /* so far only the early blocks of this stripe
-                                         * have been requested.  When later blocks
-                                         * get requested, we will try again
-                                         */
-                                        continue;
-                                if(!test_bit(STRIPE_EXPANDING, &sh2->state) ||
-                                   test_bit(R5_Expanded, &sh2->dev[dd_idx].flags)) {
-                                        /* must have already done this block */
-                                        release_stripe(sh2);
-                                        continue;
-                                }
-                                memcpy(page_address(sh2->dev[dd_idx].page),
-                                       page_address(sh->dev[i].page),
-                                       STRIPE_SIZE);
-                                set_bit(R5_Expanded, &sh2->dev[dd_idx].flags);
-                                set_bit(R5_UPTODATE, &sh2->dev[dd_idx].flags);
-                                for (j=0; j<conf->raid_disks; j++)
-                                        if (j != sh2->pd_idx &&
-                                            !test_bit(R5_Expanded, &sh2->dev[j].flags))
-                                                break;
-                                if (j == conf->raid_disks) {
-                                        set_bit(STRIPE_EXPAND_READY, &sh2->state);
-                                        set_bit(STRIPE_HANDLE, &sh2->state);
-                                }
-                                release_stripe(sh2);
-                        }
-        }
+        if (s.expanding && s.locked == 0)
+                handle_stripe_expansion(conf, sh, NULL);
+
+        if (sh->ops.count)
+                pending = get_stripe_work(sh);
 
         spin_unlock(&sh->lock);
 
-        while ((bi=return_bi)) {
-                int bytes = bi->bi_size;
+        if (pending)
+                raid5_run_ops(sh, pending);
 
-                return_bi = bi->bi_next;
-                bi->bi_next = NULL;
-                bi->bi_size = 0;
-                bi->bi_end_io(bi, bytes,
-                              test_bit(BIO_UPTODATE, &bi->bi_flags)
-                                ? 0 : -EIO);
-        }
-        for (i=disks; i-- ;) {
-                int rw;
-                struct bio *bi;
-                mdk_rdev_t *rdev;
-                if (test_and_clear_bit(R5_Wantwrite, &sh->dev[i].flags))
-                        rw = WRITE;
-                else if (test_and_clear_bit(R5_Wantread, &sh->dev[i].flags))
-                        rw = READ;
-                else
-                        continue;
- 
-                bi = &sh->dev[i].req;
- 
-                bi->bi_rw = rw;
-                if (rw == WRITE)
-                        bi->bi_end_io = raid5_end_write_request;
-                else
-                        bi->bi_end_io = raid5_end_read_request;
- 
-                rcu_read_lock();
-                rdev = rcu_dereference(conf->disks[i].rdev);
-                if (rdev && test_bit(Faulty, &rdev->flags))
-                        rdev = NULL;
-                if (rdev)
-                        atomic_inc(&rdev->nr_pending);
-                rcu_read_unlock();
- 
-                if (rdev) {
-                        if (syncing || expanding || expanded)
-                                md_sync_acct(rdev->bdev, STRIPE_SECTORS);
+        return_io(return_bi);
 
-                        bi->bi_bdev = rdev->bdev;
-                        PRINTK("for %llu schedule op %ld on disc %d\n",
-                                (unsigned long long)sh->sector, bi->bi_rw, i);
-                        atomic_inc(&sh->count);
-                        bi->bi_sector = sh->sector + rdev->data_offset;
-                        bi->bi_flags = 1 << BIO_UPTODATE;
-                        bi->bi_vcnt = 1;        
-                        bi->bi_max_vecs = 1;
-                        bi->bi_idx = 0;
-                        bi->bi_io_vec = &sh->dev[i].vec;
-                        bi->bi_io_vec[0].bv_len = STRIPE_SIZE;
-                        bi->bi_io_vec[0].bv_offset = 0;
-                        bi->bi_size = STRIPE_SIZE;
-                        bi->bi_next = NULL;
-                        if (rw == WRITE &&
-                            test_bit(R5_ReWrite, &sh->dev[i].flags))
-                                atomic_add(STRIPE_SECTORS, &rdev->corrected_errors);
-                        generic_make_request(bi);
-                } else {
-                        if (rw == WRITE)
-                                set_bit(STRIPE_DEGRADED, &sh->state);
-                        PRINTK("skip op %ld on disc %d for sector %llu\n",
-                                bi->bi_rw, i, (unsigned long long)sh->sector);
-                        clear_bit(R5_LOCKED, &sh->dev[i].flags);
-                        set_bit(STRIPE_HANDLE, &sh->state);
-                }
-        }
 }
 
 static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
 {
         raid6_conf_t *conf = sh->raid_conf;
         int disks = sh->disks;
-        struct bio *return_bi= NULL;
-        struct bio *bi;
-        int i;
-        int syncing, expanding, expanded;
-        int locked=0, uptodate=0, to_read=0, to_write=0, failed=0, written=0;
-        int non_overwrite = 0;
-        int failed_num[2] = {0, 0};
+        struct bio *return_bi = NULL;
+        int i, pd_idx = sh->pd_idx;
+        struct stripe_head_state s;
+        struct r6_state r6s;
         struct r5dev *dev, *pdev, *qdev;
-        int pd_idx = sh->pd_idx;
-        int qd_idx = raid6_next_disk(pd_idx, disks);
-        int p_failed, q_failed;
 
-        PRINTK("handling stripe %llu, state=%#lx cnt=%d, pd_idx=%d, qd_idx=%d\n",
-               (unsigned long long)sh->sector, sh->state, atomic_read(&sh->count),
-               pd_idx, qd_idx);
+        r6s.qd_idx = raid6_next_disk(pd_idx, disks);
+        pr_debug("handling stripe %llu, state=%#lx cnt=%d, "
+                "pd_idx=%d, qd_idx=%d\n",
+               (unsigned long long)sh->sector, sh->state,
+               atomic_read(&sh->count), pd_idx, r6s.qd_idx);
+        memset(&s, 0, sizeof(s));
 
         spin_lock(&sh->lock);
         clear_bit(STRIPE_HANDLE, &sh->state);
         clear_bit(STRIPE_DELAYED, &sh->state);
 
-        syncing = test_bit(STRIPE_SYNCING, &sh->state);
-        expanding = test_bit(STRIPE_EXPAND_SOURCE, &sh->state);
-        expanded = test_bit(STRIPE_EXPAND_READY, &sh->state);
+        s.syncing = test_bit(STRIPE_SYNCING, &sh->state);
+        s.expanding = test_bit(STRIPE_EXPAND_SOURCE, &sh->state);
+        s.expanded = test_bit(STRIPE_EXPAND_READY, &sh->state);
         /* Now to look around and see what can be done */
 
         rcu_read_lock();
@@ -1917,12 +2911,12 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                 dev = &sh->dev[i];
                 clear_bit(R5_Insync, &dev->flags);
 
-                PRINTK("check %d: state 0x%lx read %p write %p written %p\n",
+                pr_debug("check %d: state 0x%lx read %p write %p written %p\n",
                         i, dev->flags, dev->toread, dev->towrite, dev->written);
                 /* maybe we can reply to a read */
                 if (test_bit(R5_UPTODATE, &dev->flags) && dev->toread) {
                         struct bio *rbi, *rbi2;
-                        PRINTK("Return read for disc %d\n", i);
+                        pr_debug("Return read for disc %d\n", i);
                         spin_lock_irq(&conf->device_lock);
                         rbi = dev->toread;
                         dev->toread = NULL;
@@ -1943,17 +2937,19 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                 }
 
                 /* now count some things */
-                if (test_bit(R5_LOCKED, &dev->flags)) locked++;
-                if (test_bit(R5_UPTODATE, &dev->flags)) uptodate++;
+                if (test_bit(R5_LOCKED, &dev->flags)) s.locked++;
+                if (test_bit(R5_UPTODATE, &dev->flags)) s.uptodate++;
 
 
-                if (dev->toread) to_read++;
+                if (dev->toread)
+                        s.to_read++;
                 if (dev->towrite) {
-                        to_write++;
+                        s.to_write++;
                         if (!test_bit(R5_OVERWRITE, &dev->flags))
-                                non_overwrite++;
+                                s.non_overwrite++;
                 }
-                if (dev->written) written++;
+                if (dev->written)
+                        s.written++;
                 rdev = rcu_dereference(conf->disks[i].rdev);
                 if (!rdev || !test_bit(In_sync, &rdev->flags)) {
                         /* The ReadError flag will just be confusing now */
@@ -1962,96 +2958,27 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                 }
                 if (!rdev || !test_bit(In_sync, &rdev->flags)
                     || test_bit(R5_ReadError, &dev->flags)) {
-                        if ( failed < 2 )
-                                failed_num[failed] = i;
-                        failed++;
+                        if (s.failed < 2)
+                                r6s.failed_num[s.failed] = i;
+                        s.failed++;
                 } else
                         set_bit(R5_Insync, &dev->flags);
         }
         rcu_read_unlock();
-        PRINTK("locked=%d uptodate=%d to_read=%d"
+        pr_debug("locked=%d uptodate=%d to_read=%d"
                " to_write=%d failed=%d failed_num=%d,%d\n",
-               locked, uptodate, to_read, to_write, failed,
-               failed_num[0], failed_num[1]);
-        /* check if the array has lost >2 devices and, if so, some requests might
-         * need to be failed
+               s.locked, s.uptodate, s.to_read, s.to_write, s.failed,
+               r6s.failed_num[0], r6s.failed_num[1]);
+        /* check if the array has lost >2 devices and, if so, some requests
+         * might need to be failed
          */
-        if (failed > 2 && to_read+to_write+written) {
-                for (i=disks; i--; ) {
-                        int bitmap_end = 0;
-
-                        if (test_bit(R5_ReadError, &sh->dev[i].flags)) {
-                                mdk_rdev_t *rdev;
-                                rcu_read_lock();
-                                rdev = rcu_dereference(conf->disks[i].rdev);
-                                if (rdev && test_bit(In_sync, &rdev->flags))
-                                        /* multiple read failures in one stripe */
-                                        md_error(conf->mddev, rdev);
-                                rcu_read_unlock();
-                        }
-
-                        spin_lock_irq(&conf->device_lock);
-                        /* fail all writes first */
-                        bi = sh->dev[i].towrite;
-                        sh->dev[i].towrite = NULL;
-                        if (bi) { to_write--; bitmap_end = 1; }
-
-                        if (test_and_clear_bit(R5_Overlap, &sh->dev[i].flags))
-                                wake_up(&conf->wait_for_overlap);
-
-                        while (bi && bi->bi_sector < sh->dev[i].sector + STRIPE_SECTORS){
-                                struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);
-                                clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                                if (--bi->bi_phys_segments == 0) {
-                                        md_write_end(conf->mddev);
-                                        bi->bi_next = return_bi;
-                                        return_bi = bi;
-                                }
-                                bi = nextbi;
-                        }
-                        /* and fail all 'written' */
-                        bi = sh->dev[i].written;
-                        sh->dev[i].written = NULL;
-                        if (bi) bitmap_end = 1;
-                        while (bi && bi->bi_sector < sh->dev[i].sector + STRIPE_SECTORS) {
-                                struct bio *bi2 = r5_next_bio(bi, sh->dev[i].sector);
-                                clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                                if (--bi->bi_phys_segments == 0) {
-                                        md_write_end(conf->mddev);
-                                        bi->bi_next = return_bi;
-                                        return_bi = bi;
-                                }
-                                bi = bi2;
-                        }
-
-                        /* fail any reads if this device is non-operational */
-                        if (!test_bit(R5_Insync, &sh->dev[i].flags) ||
-                            test_bit(R5_ReadError, &sh->dev[i].flags)) {
-                                bi = sh->dev[i].toread;
-                                sh->dev[i].toread = NULL;
-                                if (test_and_clear_bit(R5_Overlap, &sh->dev[i].flags))
-                                        wake_up(&conf->wait_for_overlap);
-                                if (bi) to_read--;
-                                while (bi && bi->bi_sector < sh->dev[i].sector + STRIPE_SECTORS){
-                                        struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);
-                                        clear_bit(BIO_UPTODATE, &bi->bi_flags);
-                                        if (--bi->bi_phys_segments == 0) {
-                                                bi->bi_next = return_bi;
-                                                return_bi = bi;
-                                        }
-                                        bi = nextbi;
-                                }
-                        }
-                        spin_unlock_irq(&conf->device_lock);
-                        if (bitmap_end)
-                                bitmap_endwrite(conf->mddev->bitmap, sh->sector,
-                                                STRIPE_SECTORS, 0, 0);
-                }
-        }
-        if (failed > 2 && syncing) {
+        if (s.failed > 2 && s.to_read+s.to_write+s.written)
+                handle_requests_to_failed_array(conf, sh, &s, disks,
+                                                &return_bi);
+        if (s.failed > 2 && s.syncing) {
                 md_done_sync(conf->mddev, STRIPE_SECTORS,0);
                 clear_bit(STRIPE_SYNCING, &sh->state);
-                syncing = 0;
+                s.syncing = 0;
         }
 
         /*
@@ -2059,279 +2986,41 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
          * are safe, or on a failed drive
          */
         pdev = &sh->dev[pd_idx];
-        p_failed = (failed >= 1 && failed_num[0] == pd_idx)
-                || (failed >= 2 && failed_num[1] == pd_idx);
-        qdev = &sh->dev[qd_idx];
-        q_failed = (failed >= 1 && failed_num[0] == qd_idx)
-                || (failed >= 2 && failed_num[1] == qd_idx);
-
-        if ( written &&
-             ( p_failed || ((test_bit(R5_Insync, &pdev->flags)
+        r6s.p_failed = (s.failed >= 1 && r6s.failed_num[0] == pd_idx)
+                || (s.failed >= 2 && r6s.failed_num[1] == pd_idx);
+        qdev = &sh->dev[r6s.qd_idx];
+        r6s.q_failed = (s.failed >= 1 && r6s.failed_num[0] == r6s.qd_idx)
+                || (s.failed >= 2 && r6s.failed_num[1] == r6s.qd_idx);
+
+        if ( s.written &&
+             ( r6s.p_failed || ((test_bit(R5_Insync, &pdev->flags)
                              && !test_bit(R5_LOCKED, &pdev->flags)
-                             && test_bit(R5_UPTODATE, &pdev->flags))) ) &&
-             ( q_failed || ((test_bit(R5_Insync, &qdev->flags)
+                             && test_bit(R5_UPTODATE, &pdev->flags)))) &&
+             ( r6s.q_failed || ((test_bit(R5_Insync, &qdev->flags)
                              && !test_bit(R5_LOCKED, &qdev->flags)
-                             && test_bit(R5_UPTODATE, &qdev->flags))) ) ) {
-                /* any written block on an uptodate or failed drive can be
-                 * returned.  Note that if we 'wrote' to a failed drive,
-                 * it will be UPTODATE, but never LOCKED, so we don't need
-                 * to test 'failed' directly.
-                 */
-                for (i=disks; i--; )
-                        if (sh->dev[i].written) {
-                                dev = &sh->dev[i];
-                                if (!test_bit(R5_LOCKED, &dev->flags) &&
-                                    test_bit(R5_UPTODATE, &dev->flags) ) {
-                                        /* We can return any write requests */
-                                        int bitmap_end = 0;
-                                        struct bio *wbi, *wbi2;
-                                        PRINTK("Return write for stripe %llu disc %d\n",
-                                               (unsigned long long)sh->sector, i);
-                                        spin_lock_irq(&conf->device_lock);
-                                        wbi = dev->written;
-                                        dev->written = NULL;
-                                        while (wbi && wbi->bi_sector < dev->sector + STRIPE_SECTORS) {
-                                                wbi2 = r5_next_bio(wbi, dev->sector);
-                                                if (--wbi->bi_phys_segments == 0) {
-                                                        md_write_end(conf->mddev);
-                                                        wbi->bi_next = return_bi;
-                                                        return_bi = wbi;
-                                                }
-                                                wbi = wbi2;
-                                        }
-                                        if (dev->towrite == NULL)
-                                                bitmap_end = 1;
-                                        spin_unlock_irq(&conf->device_lock);
-                                        if (bitmap_end)
-                                                bitmap_endwrite(conf->mddev->bitmap, sh->sector,
-                                                                STRIPE_SECTORS,
-                                                                !test_bit(STRIPE_DEGRADED, &sh->state), 0);
-                                }
-                        }
-        }
+                             && test_bit(R5_UPTODATE, &qdev->flags)))))
+                handle_completed_write_requests(conf, sh, disks, &return_bi);
 
         /* Now we might consider reading some blocks, either to check/generate
          * parity, or to satisfy requests
          * or to load a block that is being partially written.
          */
-        if (to_read || non_overwrite || (to_write && failed) ||
-            (syncing && (uptodate < disks)) || expanding) {
-                for (i=disks; i--;) {
-                        dev = &sh->dev[i];
-                        if (!test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) &&
-                            (dev->toread ||
-                             (dev->towrite && !test_bit(R5_OVERWRITE, &dev->flags)) ||
-                             syncing ||
-                             expanding ||
-                             (failed >= 1 && (sh->dev[failed_num[0]].toread || to_write)) ||
-                             (failed >= 2 && (sh->dev[failed_num[1]].toread || to_write))
-                                    )
-                                ) {
-                                /* we would like to get this block, possibly
-                                 * by computing it, but we might not be able to
-                                 */
-                                if (uptodate == disks-1) {
-                                        PRINTK("Computing stripe %llu block %d\n",
-                                               (unsigned long long)sh->sector, i);
-                                        compute_block_1(sh, i, 0);
-                                        uptodate++;
-                                } else if ( uptodate == disks-2 && failed >= 2 ) {
-                                        /* Computing 2-failure is *very* expensive; only do it if failed >= 2 */
-                                        int other;
-                                        for (other=disks; other--;) {
-                                                if ( other == i )
-                                                        continue;
-                                                if ( !test_bit(R5_UPTODATE, &sh->dev[other].flags) )
-                                                        break;
-                                        }
-                                        BUG_ON(other < 0);
-                                        PRINTK("Computing stripe %llu blocks %d,%d\n",
-                                               (unsigned long long)sh->sector, i, other);
-                                        compute_block_2(sh, i, other);
-                                        uptodate += 2;
-                                } else if (test_bit(R5_Insync, &dev->flags)) {
-                                        set_bit(R5_LOCKED, &dev->flags);
-                                        set_bit(R5_Wantread, &dev->flags);
-                                        locked++;
-                                        PRINTK("Reading block %d (sync=%d)\n",
-                                                i, syncing);
-                                }
-                        }
-                }
-                set_bit(STRIPE_HANDLE, &sh->state);
-        }
+        if (s.to_read || s.non_overwrite || (s.to_write && s.failed) ||
+            (s.syncing && (s.uptodate < disks)) || s.expanding)
+                handle_issuing_new_read_requests6(sh, &s, &r6s, disks);
 
         /* now to consider writing and what else, if anything should be read */
-        if (to_write) {
-                int rcw=0, must_compute=0;
-                for (i=disks ; i--;) {
-                        dev = &sh->dev[i];
-                        /* Would I have to read this buffer for reconstruct_write */
-                        if (!test_bit(R5_OVERWRITE, &dev->flags)
-                            && i != pd_idx && i != qd_idx
-                            && (!test_bit(R5_LOCKED, &dev->flags)
-                                    ) &&
-                            !test_bit(R5_UPTODATE, &dev->flags)) {
-                                if (test_bit(R5_Insync, &dev->flags)) rcw++;
-                                else {
-                                        PRINTK("raid6: must_compute: disk %d flags=%#lx\n", i, dev->flags);
-                                        must_compute++;
-                                }
-                        }
-                }
-                PRINTK("for sector %llu, rcw=%d, must_compute=%d\n",
-                       (unsigned long long)sh->sector, rcw, must_compute);
-                set_bit(STRIPE_HANDLE, &sh->state);
-
-                if (rcw > 0)
-                        /* want reconstruct write, but need to get some data */
-                        for (i=disks; i--;) {
-                                dev = &sh->dev[i];
-                                if (!test_bit(R5_OVERWRITE, &dev->flags)
-                                    && !(failed == 0 && (i == pd_idx || i == qd_idx))
-                                    && !test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) &&
-                                    test_bit(R5_Insync, &dev->flags)) {
-                                        if (test_bit(STRIPE_PREREAD_ACTIVE, &sh->state))
-                                        {
-                                                PRINTK("Read_old stripe %llu block %d for Reconstruct\n",
-                                                       (unsigned long long)sh->sector, i);
-                                                set_bit(R5_LOCKED, &dev->flags);
-                                                set_bit(R5_Wantread, &dev->flags);
-                                                locked++;
-                                        } else {
-                                                PRINTK("Request delayed stripe %llu block %d for Reconstruct\n",
-                                                       (unsigned long long)sh->sector, i);
-                                                set_bit(STRIPE_DELAYED, &sh->state);
-                                                set_bit(STRIPE_HANDLE, &sh->state);
-                                        }
-                                }
-                        }
-                /* now if nothing is locked, and if we have enough data, we can start a write request */
-                if (locked == 0 && rcw == 0 &&
-                    !test_bit(STRIPE_BIT_DELAY, &sh->state)) {
-                        if ( must_compute > 0 ) {
-                                /* We have failed blocks and need to compute them */
-                                switch ( failed ) {
-                                case 0: BUG();
-                                case 1: compute_block_1(sh, failed_num[0], 0); break;
-                                case 2: compute_block_2(sh, failed_num[0], failed_num[1]); break;
-                                default: BUG(); /* This request should have been failed? */
-                                }
-                        }
-
-                        PRINTK("Computing parity for stripe %llu\n", (unsigned long long)sh->sector);
-                        compute_parity6(sh, RECONSTRUCT_WRITE);
-                        /* now every locked buffer is ready to be written */
-                        for (i=disks; i--;)
-                                if (test_bit(R5_LOCKED, &sh->dev[i].flags)) {
-                                        PRINTK("Writing stripe %llu block %d\n",
-                                               (unsigned long long)sh->sector, i);
-                                        locked++;
-                                        set_bit(R5_Wantwrite, &sh->dev[i].flags);
-                                }
-                        /* after a RECONSTRUCT_WRITE, the stripe MUST be in-sync */
-                        set_bit(STRIPE_INSYNC, &sh->state);
-
-                        if (test_and_clear_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) {
-                                atomic_dec(&conf->preread_active_stripes);
-                                if (atomic_read(&conf->preread_active_stripes) < IO_THRESHOLD)
-                                        md_wakeup_thread(conf->mddev->thread);
-                        }
-                }
-        }
+        if (s.to_write)
+                handle_issuing_new_write_requests6(conf, sh, &s, &r6s, disks);
 
         /* maybe we need to check and possibly fix the parity for this stripe
-         * Any reads will already have been scheduled, so we just see if enough data
-         * is available
+         * Any reads will already have been scheduled, so we just see if enough
+         * data is available
          */
-        if (syncing && locked == 0 && !test_bit(STRIPE_INSYNC, &sh->state)) {
-                int update_p = 0, update_q = 0;
-                struct r5dev *dev;
-
-                set_bit(STRIPE_HANDLE, &sh->state);
-
-                BUG_ON(failed>2);
-                BUG_ON(uptodate < disks);
-                /* Want to check and possibly repair P and Q.
-                 * However there could be one 'failed' device, in which
-                 * case we can only check one of them, possibly using the
-                 * other to generate missing data
-                 */
-
-                /* If !tmp_page, we cannot do the calculations,
-                 * but as we have set STRIPE_HANDLE, we will soon be called
-                 * by stripe_handle with a tmp_page - just wait until then.
-                 */
-                if (tmp_page) {
-                        if (failed == q_failed) {
-                                /* The only possible failed device holds 'Q', so it makes
-                                 * sense to check P (If anything else were failed, we would
-                                 * have used P to recreate it).
-                                 */
-                                compute_block_1(sh, pd_idx, 1);
-                                if (!page_is_zero(sh->dev[pd_idx].page)) {
-                                        compute_block_1(sh,pd_idx,0);
-                                        update_p = 1;
-                                }
-                        }
-                        if (!q_failed && failed < 2) {
-                                /* q is not failed, and we didn't use it to generate
-                                 * anything, so it makes sense to check it
-                                 */
-                                memcpy(page_address(tmp_page),
-                                       page_address(sh->dev[qd_idx].page),
-                                       STRIPE_SIZE);
-                                compute_parity6(sh, UPDATE_PARITY);
-                                if (memcmp(page_address(tmp_page),
-                                           page_address(sh->dev[qd_idx].page),
-                                           STRIPE_SIZE)!= 0) {
-                                        clear_bit(STRIPE_INSYNC, &sh->state);
-                                        update_q = 1;
-                                }
-                        }
-                        if (update_p || update_q) {
-                                conf->mddev->resync_mismatches += STRIPE_SECTORS;
-                                if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery))
-                                        /* don't try to repair!! */
-                                        update_p = update_q = 0;
-                        }
-
-                        /* now write out any block on a failed drive,
-                         * or P or Q if they need it
-                         */
+        if (s.syncing && s.locked == 0 && !test_bit(STRIPE_INSYNC, &sh->state))
+                handle_parity_checks6(conf, sh, &s, &r6s, tmp_page, disks);
 
-                        if (failed == 2) {
-                                dev = &sh->dev[failed_num[1]];
-                                locked++;
-                                set_bit(R5_LOCKED, &dev->flags);
-                                set_bit(R5_Wantwrite, &dev->flags);
-                        }
-                        if (failed >= 1) {
-                                dev = &sh->dev[failed_num[0]];
-                                locked++;
-                                set_bit(R5_LOCKED, &dev->flags);
-                                set_bit(R5_Wantwrite, &dev->flags);
-                        }
-
-                        if (update_p) {
-                                dev = &sh->dev[pd_idx];
-                                locked ++;
-                                set_bit(R5_LOCKED, &dev->flags);
-                                set_bit(R5_Wantwrite, &dev->flags);
-                        }
-                        if (update_q) {
-                                dev = &sh->dev[qd_idx];
-                                locked++;
-                                set_bit(R5_LOCKED, &dev->flags);
-                                set_bit(R5_Wantwrite, &dev->flags);
-                        }
-                        clear_bit(STRIPE_DEGRADED, &sh->state);
-
-                        set_bit(STRIPE_INSYNC, &sh->state);
-                }
-        }
-
-        if (syncing && locked == 0 && test_bit(STRIPE_INSYNC, &sh->state)) {
+        if (s.syncing && s.locked == 0 && test_bit(STRIPE_INSYNC, &sh->state)) {
                 md_done_sync(conf->mddev, STRIPE_SECTORS,1);
                 clear_bit(STRIPE_SYNCING, &sh->state);
         }
@@ -2339,9 +3028,9 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
         /* If the failed drives are just a ReadError, then we might need
          * to progress the repair/check process
          */
-        if (failed <= 2 && ! conf->mddev->ro)
-                for (i=0; i<failed;i++) {
-                        dev = &sh->dev[failed_num[i]];
+        if (s.failed <= 2 && !conf->mddev->ro)
+                for (i = 0; i < s.failed; i++) {
+                        dev = &sh->dev[r6s.failed_num[i]];
                         if (test_bit(R5_ReadError, &dev->flags)
                             && !test_bit(R5_LOCKED, &dev->flags)
                             && test_bit(R5_UPTODATE, &dev->flags)
@@ -2358,7 +3047,7 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                         }
                 }
 
-        if (expanded && test_bit(STRIPE_EXPANDING, &sh->state)) {
+        if (s.expanded && test_bit(STRIPE_EXPANDING, &sh->state)) {
                 /* Need to write out all blocks after computing P&Q */
                 sh->disks = conf->raid_disks;
                 sh->pd_idx = stripe_to_pdidx(sh->sector, conf,
@@ -2366,82 +3055,24 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                 compute_parity6(sh, RECONSTRUCT_WRITE);
                 for (i = conf->raid_disks ; i-- ;  ) {
                         set_bit(R5_LOCKED, &sh->dev[i].flags);
-                        locked++;
+                        s.locked++;
                         set_bit(R5_Wantwrite, &sh->dev[i].flags);
                 }
                 clear_bit(STRIPE_EXPANDING, &sh->state);
-        } else if (expanded) {
+        } else if (s.expanded) {
                 clear_bit(STRIPE_EXPAND_READY, &sh->state);
                 atomic_dec(&conf->reshape_stripes);
                 wake_up(&conf->wait_for_overlap);
                 md_done_sync(conf->mddev, STRIPE_SECTORS, 1);
         }
 
-        if (expanding && locked == 0) {
-                /* We have read all the blocks in this stripe and now we need to
-                 * copy some of them into a target stripe for expand.
-                 */
-                clear_bit(STRIPE_EXPAND_SOURCE, &sh->state);
-                for (i = 0; i < sh->disks ; i++)
-                        if (i != pd_idx && i != qd_idx) {
-                                int dd_idx2, pd_idx2, j;
-                                struct stripe_head *sh2;
-
-                                sector_t bn = compute_blocknr(sh, i);
-                                sector_t s = raid5_compute_sector(
-                                        bn, conf->raid_disks,
-                                        conf->raid_disks - conf->max_degraded,
-                                        &dd_idx2, &pd_idx2, conf);
-                                sh2 = get_active_stripe(conf, s,
-                                                        conf->raid_disks,
-                                                       pd_idx2, 1);
-                                if (sh2 == NULL)
-                                        /* so for only the early blocks of
-                                         * this stripe have been requests.
-                                         * When later blocks get requests, we
-                                         * will try again
-                                         */
-                                        continue;
-                                if (!test_bit(STRIPE_EXPANDING, &sh2->state) ||
-                                    test_bit(R5_Expanded,
-                                             &sh2->dev[dd_idx2].flags)) {
-                                        /* must have already done this block */
-                                        release_stripe(sh2);
-                                        continue;
-                                }
-                                memcpy(page_address(sh2->dev[dd_idx2].page),
-                                       page_address(sh->dev[i].page),
-                                       STRIPE_SIZE);
-                                set_bit(R5_Expanded, &sh2->dev[dd_idx2].flags);
-                                set_bit(R5_UPTODATE, &sh2->dev[dd_idx2].flags);
-                                for (j = 0 ; j < conf->raid_disks ; j++)
-                                        if (j != sh2->pd_idx &&
-                                            j != raid6_next_disk(sh2->pd_idx,
-                                                           sh2->disks) &&
-                                            !test_bit(R5_Expanded,
-                                                      &sh2->dev[j].flags))
-                                                break;
-                                if (j == conf->raid_disks) {
-                                        set_bit(STRIPE_EXPAND_READY,
-                                                &sh2->state);
-                                        set_bit(STRIPE_HANDLE, &sh2->state);
-                                }
-                                release_stripe(sh2);
-                        }
-        }
+        if (s.expanding && s.locked == 0)
+                handle_stripe_expansion(conf, sh, &r6s);
 
         spin_unlock(&sh->lock);
 
-        while ((bi=return_bi)) {
-                int bytes = bi->bi_size;
+        return_io(return_bi);
 
-                return_bi = bi->bi_next;
-                bi->bi_next = NULL;
-                bi->bi_size = 0;
-                bi->bi_end_io(bi, bytes,
-                              test_bit(BIO_UPTODATE, &bi->bi_flags)
-                                ? 0 : -EIO);
-        }
         for (i=disks; i-- ;) {
                 int rw;
                 struct bio *bi;
@@ -2470,11 +3101,11 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                 rcu_read_unlock();
 
                 if (rdev) {
-                        if (syncing || expanding || expanded)
+                        if (s.syncing || s.expanding || s.expanded)
                                 md_sync_acct(rdev->bdev, STRIPE_SECTORS);
 
                         bi->bi_bdev = rdev->bdev;
-                        PRINTK("for %llu schedule op %ld on disc %d\n",
+                        pr_debug("for %llu schedule op %ld on disc %d\n",
                                 (unsigned long long)sh->sector, bi->bi_rw, i);
                         atomic_inc(&sh->count);
                         bi->bi_sector = sh->sector + rdev->data_offset;
@@ -2494,7 +3125,7 @@ static void handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                 } else {
                         if (rw == WRITE)
                                 set_bit(STRIPE_DEGRADED, &sh->state);
-                        PRINTK("skip op %ld on disc %d for sector %llu\n",
+                        pr_debug("skip op %ld on disc %d for sector %llu\n",
                                 bi->bi_rw, i, (unsigned long long)sh->sector);
                         clear_bit(R5_LOCKED, &sh->dev[i].flags);
                         set_bit(STRIPE_HANDLE, &sh->state);
@@ -2738,7 +3369,7 @@ static int raid5_align_endio(struct bio *bi, unsigned int bytes, int error)
         }
 
 
-        PRINTK("raid5_align_endio : io error...handing IO for a retry\n");
+        pr_debug("raid5_align_endio : io error...handing IO for a retry\n");
 
         add_bio_to_retry(raid_bi, conf);
         return 0;
@@ -2776,7 +3407,7 @@ static int chunk_aligned_read(request_queue_t *q, struct bio * raid_bio)
         mdk_rdev_t *rdev;
 
         if (!in_chunk_boundary(mddev, raid_bio)) {
-                PRINTK("chunk_aligned_read : non aligned\n");
+                pr_debug("chunk_aligned_read : non aligned\n");
                 return 0;
         }
         /*
@@ -2900,7 +3531,7 @@ static int make_request(request_queue_t *q, struct bio * bi)
 
                 new_sector = raid5_compute_sector(logical_sector, disks, data_disks,
                                                   &dd_idx, &pd_idx, conf);
-                PRINTK("raid5: make_request, sector %llu logical %llu\n",
+                pr_debug("raid5: make_request, sector %llu logical %llu\n",
                         (unsigned long long)new_sector, 
                         (unsigned long long)logical_sector);
 
@@ -3273,7 +3904,7 @@ static void raid5d (mddev_t *mddev)
         raid5_conf_t *conf = mddev_to_conf(mddev);
         int handled;
 
-        PRINTK("+++ raid5d active\n");
+        pr_debug("+++ raid5d active\n");
 
         md_check_recovery(mddev);
 
@@ -3308,8 +3939,10 @@ static void raid5d (mddev_t *mddev)
                         handled++;
                 }
 
-                if (list_empty(&conf->handle_list))
+                if (list_empty(&conf->handle_list)) {
+                        async_tx_issue_pending_all();
                         break;
+                }
 
                 first = conf->handle_list.next;
                 sh = list_entry(first, struct stripe_head, lru);
@@ -3325,13 +3958,13 @@ static void raid5d (mddev_t *mddev)
 
                 spin_lock_irq(&conf->device_lock);
         }
-        PRINTK("%d stripes handled\n", handled);
+        pr_debug("%d stripes handled\n", handled);
 
         spin_unlock_irq(&conf->device_lock);
 
         unplug_slaves(mddev);
 
-        PRINTK("--- raid5d inactive\n");
+        pr_debug("--- raid5d inactive\n");
 }
 
 static ssize_t
@@ -3507,7 +4140,7 @@ static int run(mddev_t *mddev)
         atomic_set(&conf->preread_active_stripes, 0);
         atomic_set(&conf->active_aligned_reads, 0);
 
-        PRINTK("raid5: run(%s) called.\n", mdname(mddev));
+        pr_debug("raid5: run(%s) called.\n", mdname(mddev));
 
         ITERATE_RDEV(mddev,rdev,tmp) {
                 raid_disk = rdev->raid_disk;
@@ -3690,7 +4323,7 @@ static int stop(mddev_t *mddev)
         return 0;
 }
 
-#if RAID5_DEBUG
+#ifdef DEBUG
 static void print_sh (struct seq_file *seq, struct stripe_head *sh)
 {
         int i;
@@ -3737,7 +4370,7 @@ static void status (struct seq_file *seq, mddev_t *mddev)
                                conf->disks[i].rdev &&
                                test_bit(In_sync, &conf->disks[i].rdev->flags) ? "U" : "_");
         seq_printf (seq, "]");
-#if RAID5_DEBUG
+#ifdef DEBUG
         seq_printf (seq, "\n");
         printall(seq, conf);
 #endif
diff --git a/drivers/md/xor.c b/drivers/md/xor.c
deleted file mode 100644
index 324897c4be4e..000000000000
--- a/drivers/md/xor.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * xor.c : Multiple Devices driver for Linux
- *
- * Copyright (C) 1996, 1997, 1998, 1999, 2000,
- * Ingo Molnar, Matti Aarnio, Jakub Jelinek, Richard Henderson.
- *
- * Dispatch optimized RAID-5 checksumming functions.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * You should have received a copy of the GNU General Public License
- * (for example /usr/src/linux/COPYING); if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#define BH_TRACE 0
-#include <linux/module.h>
-#include <linux/raid/md.h>
-#include <linux/raid/xor.h>
-#include <asm/xor.h>
-
-/* The xor routines to use.  */
-static struct xor_block_template *active_template;
-
-void
-xor_block(unsigned int count, unsigned int bytes, void **ptr)
-{
-        unsigned long *p0, *p1, *p2, *p3, *p4;
-
-        p0 = (unsigned long *) ptr[0];
-        p1 = (unsigned long *) ptr[1];
-        if (count == 2) {
-                active_template->do_2(bytes, p0, p1);
-                return;
-        }
-
-        p2 = (unsigned long *) ptr[2];
-        if (count == 3) {
-                active_template->do_3(bytes, p0, p1, p2);
-                return;
-        }
-
-        p3 = (unsigned long *) ptr[3];
-        if (count == 4) {
-                active_template->do_4(bytes, p0, p1, p2, p3);
-                return;
-        }
-
-        p4 = (unsigned long *) ptr[4];
-        active_template->do_5(bytes, p0, p1, p2, p3, p4);
-}
-
-/* Set of all registered templates.  */
-static struct xor_block_template *template_list;
-
-#define BENCH_SIZE (PAGE_SIZE)
-
-static void
-do_xor_speed(struct xor_block_template *tmpl, void *b1, void *b2)
-{
-        int speed;
-        unsigned long now;
-        int i, count, max;
-
-        tmpl->next = template_list;
-        template_list = tmpl;
-
-        /*
-         * Count the number of XORs done during a whole jiffy, and use
-         * this to calculate the speed of checksumming.  We use a 2-page
-         * allocation to have guaranteed color L1-cache layout.
-         */
-        max = 0;
-        for (i = 0; i < 5; i++) {
-                now = jiffies;
-                count = 0;
-                while (jiffies == now) {
-                        mb();
-                        tmpl->do_2(BENCH_SIZE, b1, b2);
-                        mb();
-                        count++;
-                        mb();
-                }
-                if (count > max)
-                        max = count;
-        }
-
-        speed = max * (HZ * BENCH_SIZE / 1024);
-        tmpl->speed = speed;
-
-        printk("   %-10s: %5d.%03d MB/sec\n", tmpl->name,
-               speed / 1000, speed % 1000);
-}
-
-static int
-calibrate_xor_block(void)
-{
-        void *b1, *b2;
-        struct xor_block_template *f, *fastest;
-
-        b1 = (void *) __get_free_pages(GFP_KERNEL, 2);
-        if (! b1) {
-                printk("raid5: Yikes!  No memory available.\n");
-                return -ENOMEM;
-        }
-        b2 = b1 + 2*PAGE_SIZE + BENCH_SIZE;
-
-        /*
-         * If this arch/cpu has a short-circuited selection, don't loop through all
-         * the possible functions, just test the best one
-         */
-
-        fastest = NULL;
-
-#ifdef XOR_SELECT_TEMPLATE
-                fastest = XOR_SELECT_TEMPLATE(fastest);
-#endif
-
-#define xor_speed(templ)        do_xor_speed((templ), b1, b2)
-
-        if (fastest) {
-                printk(KERN_INFO "raid5: automatically using best checksumming function: %s\n",
-                        fastest->name);
-                xor_speed(fastest);
-        } else {
-                printk(KERN_INFO "raid5: measuring checksumming speed\n");
-                XOR_TRY_TEMPLATES;
-                fastest = template_list;
-                for (f = fastest; f; f = f->next)
-                        if (f->speed > fastest->speed)
-                                fastest = f;
-        }
-
-        printk("raid5: using function: %s (%d.%03d MB/sec)\n",
-               fastest->name, fastest->speed / 1000, fastest->speed % 1000);
-
-#undef xor_speed
-
-        free_pages((unsigned long)b1, 2);
-
-        active_template = fastest;
-        return 0;
-}
-
-static __exit void xor_exit(void) { }
-
-EXPORT_SYMBOL(xor_block);
-MODULE_LICENSE("GPL");
-
-module_init(calibrate_xor_block);
-module_exit(xor_exit);