42 files changed, 101 insertions, 591 deletions
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 9279272b3732..35658f445fca 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -3170,12 +3170,6 @@ static void do_cciss_request(struct request_queue *q)
        int sg_index = 0;
        int chained = 0;
-        /* We call start_io here in case there is a command waiting on the
-         * queue that has not been sent.
-         */
-        if (blk_queue_plugged(q))
-                goto startio;
      queue:
        creq = blk_peek_request(q);
        if (!creq)
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 946dad4caef3..b2fceb53e809 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -911,9 +911,6 @@ static void do_ida_request(struct request_queue *q)
        struct scatterlist tmp_sg[SG_MAX];
        int i, dir, seg;
-        if (blk_queue_plugged(q))
-                goto startio;
 queue_next:
        creq = blk_peek_request(q);
        if (!creq)
diff --git a/drivers/block/drbd/drbd_actlog.c b/drivers/block/drbd/drbd_actlog.c
index ba95cba192be..aca302492ff2 100644
--- a/drivers/block/drbd/drbd_actlog.c
+++ b/drivers/block/drbd/drbd_actlog.c
@@ -80,7 +80,7 @@ static int _drbd_md_sync_page_io(struct drbd_conf *mdev,
        if ((rw & WRITE) && !test_bit(MD_NO_FUA, &mdev->flags))
                rw |= REQ_FUA;
-        rw |= REQ_UNPLUG | REQ_SYNC;
+        rw |= REQ_SYNC;
        bio = bio_alloc(GFP_NOIO, 1);
        bio->bi_bdev = bdev->md_bdev;
@@ -689,8 +689,6 @@ void drbd_al_to_on_disk_bm(struct drbd_conf *mdev)
                }
        }
-        drbd_blk_run_queue(bdev_get_queue(mdev->ldev->md_bdev));
        /* always (try to) flush bitmap to stable storage */
        drbd_md_flush(mdev);
diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
index fd42832f785b..0645ca829a94 100644
--- a/drivers/block/drbd/drbd_bitmap.c
+++ b/drivers/block/drbd/drbd_bitmap.c
@@ -840,7 +840,6 @@ static int bm_rw(struct drbd_conf *mdev, int rw) __must_hold(local)
        for (i = 0; i < num_pages; i++)
                bm_page_io_async(mdev, b, i, rw);
-        drbd_blk_run_queue(bdev_get_queue(mdev->ldev->md_bdev));
        wait_event(b->bm_io_wait, atomic_read(&b->bm_async_io) == 0);
        if (test_bit(BM_MD_IO_ERROR, &b->bm_flags)) {
diff --git a/drivers/block/drbd/drbd_int.h b/drivers/block/drbd/drbd_int.h
index 3803a0348937..b0bd27dfc1e8 100644
--- a/drivers/block/drbd/drbd_int.h
+++ b/drivers/block/drbd/drbd_int.h
@@ -377,7 +377,7 @@ union p_header {
 #define DP_HARDBARRIER        1 /* depricated */
 #define DP_RW_SYNC            2 /* equals REQ_SYNC    */
 #define DP_MAY_SET_IN_SYNC    4
-#define DP_UNPLUG             8 /* equals REQ_UNPLUG  */
+#define DP_UNPLUG             8 /* not used anymore   */
 #define DP_FUA               16 /* equals REQ_FUA     */
 #define DP_FLUSH             32 /* equals REQ_FLUSH   */
 #define DP_DISCARD           64 /* equals REQ_DISCARD */
@@ -2382,20 +2382,6 @@ static inline int drbd_queue_order_type(struct drbd_conf *mdev)
        return QUEUE_ORDERED_NONE;
 }
-static inline void drbd_blk_run_queue(struct request_queue *q)
-{
-        if (q && q->unplug_fn)
-                q->unplug_fn(q);
-}
-static inline void drbd_kick_lo(struct drbd_conf *mdev)
-{
-        if (get_ldev(mdev)) {
-                drbd_blk_run_queue(bdev_get_queue(mdev->ldev->backing_bdev));
-                put_ldev(mdev);
-        }
-}
 static inline void drbd_md_flush(struct drbd_conf *mdev)
 {
        int r;
diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index 29cd0dc9fe4f..8a43ce0edeed 100644
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -2477,12 +2477,11 @@ static u32 bio_flags_to_wire(struct drbd_conf *mdev, unsigned long bi_rw)
 {
        if (mdev->agreed_pro_version >= 95)
                return  (bi_rw & REQ_SYNC ? DP_RW_SYNC : 0) |
-                        (bi_rw & REQ_UNPLUG ? DP_UNPLUG : 0) |
                        (bi_rw & REQ_FUA ? DP_FUA : 0) |
                        (bi_rw & REQ_FLUSH ? DP_FLUSH : 0) |
                        (bi_rw & REQ_DISCARD ? DP_DISCARD : 0);
        else
-                return bi_rw & (REQ_SYNC | REQ_UNPLUG) ? DP_RW_SYNC : 0;
+                return bi_rw & REQ_SYNC ? DP_RW_SYNC : 0;
 }
 /* Used to send write requests
@@ -2719,35 +2718,6 @@ static int drbd_release(struct gendisk *gd, fmode_t mode)
        return 0;
 }
-static void drbd_unplug_fn(struct request_queue *q)
-{
-        struct drbd_conf *mdev = q->queuedata;
-        /* unplug FIRST */
-        spin_lock_irq(q->queue_lock);
-        blk_remove_plug(q);
-        spin_unlock_irq(q->queue_lock);
-        /* only if connected */
-        spin_lock_irq(&mdev->req_lock);
-        if (mdev->state.pdsk >= D_INCONSISTENT && mdev->state.conn >= C_CONNECTED) {
-                D_ASSERT(mdev->state.role == R_PRIMARY);
-                if (test_and_clear_bit(UNPLUG_REMOTE, &mdev->flags)) {
-                        /* add to the data.work queue,
-                         * unless already queued.
-                         * XXX this might be a good addition to drbd_queue_work
-                         * anyways, to detect "double queuing" ... */
-                        if (list_empty(&mdev->unplug_work.list))
-                                drbd_queue_work(&mdev->data.work,
-                                                &mdev->unplug_work);
-                }
-        }
-        spin_unlock_irq(&mdev->req_lock);
-        if (mdev->state.disk >= D_INCONSISTENT)
-                drbd_kick_lo(mdev);
-}
 static void drbd_set_defaults(struct drbd_conf *mdev)
 {
        /* This way we get a compile error when sync_conf grows,
@@ -3222,9 +3192,7 @@ struct drbd_conf *drbd_new_device(unsigned int minor)
        blk_queue_max_segment_size(q, DRBD_MAX_SEGMENT_SIZE);
        blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
        blk_queue_merge_bvec(q, drbd_merge_bvec);
-        q->queue_lock = &mdev->req_lock; /* needed since we use */
+        q->queue_lock = &mdev->req_lock;
-                /* plugging on a queue, that actually has no requests! */
-        q->unplug_fn = drbd_unplug_fn;
        mdev->md_io_page = alloc_page(GFP_KERNEL);
        if (!mdev->md_io_page)
diff --git a/drivers/block/drbd/drbd_receiver.c b/drivers/block/drbd/drbd_receiver.c
index 24487d4fb202..8e68be939deb 100644
--- a/drivers/block/drbd/drbd_receiver.c
+++ b/drivers/block/drbd/drbd_receiver.c
@@ -187,15 +187,6 @@ static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int
        return NULL;
 }
-/* kick lower level device, if we have more than (arbitrary number)
- * reference counts on it, which typically are locally submitted io
- * requests.  don't use unacked_cnt, so we speed up proto A and B, too. */
-static void maybe_kick_lo(struct drbd_conf *mdev)
-{
-        if (atomic_read(&mdev->local_cnt) >= mdev->net_conf->unplug_watermark)
-                drbd_kick_lo(mdev);
-}
 static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed)
 {
        struct drbd_epoch_entry *e;
@@ -219,7 +210,6 @@ static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev)
        LIST_HEAD(reclaimed);
        struct drbd_epoch_entry *e, *t;
-        maybe_kick_lo(mdev);
        spin_lock_irq(&mdev->req_lock);
        reclaim_net_ee(mdev, &reclaimed);
        spin_unlock_irq(&mdev->req_lock);
@@ -436,8 +426,7 @@ void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head)
        while (!list_empty(head)) {
                prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE);
                spin_unlock_irq(&mdev->req_lock);
-                drbd_kick_lo(mdev);
+                io_schedule();
-                schedule();
                finish_wait(&mdev->ee_wait, &wait);
                spin_lock_irq(&mdev->req_lock);
        }
@@ -1111,8 +1100,6 @@ next_bio:
        /* > e->sector, unless this is the first bio */
        bio->bi_sector = sector;
        bio->bi_bdev = mdev->ldev->backing_bdev;
-        /* we special case some flags in the multi-bio case, see below
-         * (REQ_UNPLUG) */
        bio->bi_rw = rw;
        bio->bi_private = e;
        bio->bi_end_io = drbd_endio_sec;
@@ -1141,13 +1128,8 @@ next_bio:
                bios = bios->bi_next;
                bio->bi_next = NULL;
-                /* strip off REQ_UNPLUG unless it is the last bio */
-                if (bios)
-                        bio->bi_rw &= ~REQ_UNPLUG;
                drbd_generic_make_request(mdev, fault_type, bio);
        } while (bios);
-        maybe_kick_lo(mdev);
        return 0;
 fail:
@@ -1167,9 +1149,6 @@ static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packets cmd, unsign
        inc_unacked(mdev);
-        if (mdev->net_conf->wire_protocol != DRBD_PROT_C)
-                drbd_kick_lo(mdev);
        mdev->current_epoch->barrier_nr = p->barrier;
        rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR);
@@ -1636,12 +1615,11 @@ static unsigned long write_flags_to_bio(struct drbd_conf *mdev, u32 dpf)
 {
        if (mdev->agreed_pro_version >= 95)
                return  (dpf & DP_RW_SYNC ? REQ_SYNC : 0) |
-                        (dpf & DP_UNPLUG ? REQ_UNPLUG : 0) |
                        (dpf & DP_FUA ? REQ_FUA : 0) |
                        (dpf & DP_FLUSH ? REQ_FUA : 0) |
                        (dpf & DP_DISCARD ? REQ_DISCARD : 0);
        else
-                return dpf & DP_RW_SYNC ? (REQ_SYNC | REQ_UNPLUG) : 0;
+                return dpf & DP_RW_SYNC ? REQ_SYNC : 0;
 }
 /* mirrored write */
@@ -3556,9 +3534,6 @@ static int receive_skip(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned
 static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
 {
-        if (mdev->state.disk >= D_INCONSISTENT)
-                drbd_kick_lo(mdev);
        /* Make sure we've acked all the TCP data associated
         * with the data requests being unplugged */
        drbd_tcp_quickack(mdev->data.socket);
diff --git a/drivers/block/drbd/drbd_req.c b/drivers/block/drbd/drbd_req.c
index 11a75d32a2e2..ad3fc6228f27 100644
--- a/drivers/block/drbd/drbd_req.c
+++ b/drivers/block/drbd/drbd_req.c
@@ -960,10 +960,6 @@ allocate_barrier:
                        bio_endio(req->private_bio, -EIO);
        }
-        /* we need to plug ALWAYS since we possibly need to kick lo_dev.
-         * we plug after submit, so we won't miss an unplug event */
-        drbd_plug_device(mdev);
        return 0;
 fail_conflicting:
diff --git a/drivers/block/drbd/drbd_worker.c b/drivers/block/drbd/drbd_worker.c
index 34f224b018b3..e027446590d3 100644
--- a/drivers/block/drbd/drbd_worker.c
+++ b/drivers/block/drbd/drbd_worker.c
@@ -792,7 +792,6 @@ int drbd_resync_finished(struct drbd_conf *mdev)
                 * queue (or even the read operations for those packets
                 * is not finished by now).   Retry in 100ms. */
-                drbd_kick_lo(mdev);
                __set_current_state(TASK_INTERRUPTIBLE);
                schedule_timeout(HZ / 10);
                w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC);
diff --git a/drivers/block/drbd/drbd_wrappers.h b/drivers/block/drbd/drbd_wrappers.h
index defdb5013ea3..53586fa5ae1b 100644
--- a/drivers/block/drbd/drbd_wrappers.h
+++ b/drivers/block/drbd/drbd_wrappers.h
@@ -45,24 +45,6 @@ static inline void drbd_generic_make_request(struct drbd_conf *mdev,
                generic_make_request(bio);
 }
-static inline void drbd_plug_device(struct drbd_conf *mdev)
-{
-        struct request_queue *q;
-        q = bdev_get_queue(mdev->this_bdev);
-        spin_lock_irq(q->queue_lock);
-/* XXX the check on !blk_queue_plugged is redundant,
- * implicitly checked in blk_plug_device */
-        if (!blk_queue_plugged(q)) {
-                blk_plug_device(q);
-                del_timer(&q->unplug_timer);
-                /* unplugging should not happen automatically... */
-        }
-        spin_unlock_irq(q->queue_lock);
-}
 static inline int drbd_crypto_is_hash(struct crypto_tfm *tfm)
 {
        return (crypto_tfm_alg_type(tfm) & CRYPTO_ALG_TYPE_HASH_MASK)
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 3851dbc03e05..301d7a9a41a6 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -3838,7 +3838,6 @@ static int __floppy_read_block_0(struct block_device *bdev)
        bio.bi_end_io = floppy_rb0_complete;
        submit_bio(READ, &bio);
-        generic_unplug_device(bdev_get_queue(bdev));
        process_fd_request();
        wait_for_completion(&complete);
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 79c3079a6203..a076a14ca72d 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -540,17 +540,6 @@ out:
        return 0;
 }
-/*
- * kick off io on the underlying address space
- */
-static void loop_unplug(struct request_queue *q)
-{
-        struct loop_device *lo = q->queuedata;
-        queue_flag_clear_unlocked(QUEUE_FLAG_PLUGGED, q);
-        blk_run_address_space(lo->lo_backing_file->f_mapping);
-}
 struct switch_request {
        struct file *file;
        struct completion wait;
@@ -917,7 +906,6 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
         */
        blk_queue_make_request(lo->lo_queue, loop_make_request);
        lo->lo_queue->queuedata = lo;
-        lo->lo_queue->unplug_fn = loop_unplug;
        if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
                blk_queue_flush(lo->lo_queue, REQ_FLUSH);
@@ -1019,7 +1007,6 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
        kthread_stop(lo->lo_thread);
-        lo->lo_queue->unplug_fn = NULL;
        lo->lo_backing_file = NULL;
        loop_release_xfer(lo);
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index a077db27b7c9..07a382eaf0a8 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -1606,8 +1606,6 @@ static int kcdrwd(void *foobar)
                                        min_sleep_time = pkt->sleep_time;
                        }
-                        generic_unplug_device(bdev_get_queue(pd->bdev));
                        VPRINTK("kcdrwd: sleeping\n");
                        residue = schedule_timeout(min_sleep_time);
                        VPRINTK("kcdrwd: wake up\n");
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index 9b102abe209c..031ca720d926 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -241,8 +241,7 @@ static void dump_dmastat(struct cardinfo *card, unsigned int dmastat)
 *
 * Whenever IO on the active page completes, the Ready page is activated
 * and the ex-Active page is clean out and made Ready.
- * Otherwise the Ready page is only activated when it becomes full, or
+ * Otherwise the Ready page is only activated when it becomes full.
- * when mm_unplug_device is called via the unplug_io_fn.
 *
 * If a request arrives while both pages a full, it is queued, and b_rdev is
 * overloaded to record whether it was a read or a write.
@@ -333,17 +332,6 @@ static inline void reset_page(struct mm_page *page)
        page->biotail = &page->bio;
 }
-static void mm_unplug_device(struct request_queue *q)
-{
-        struct cardinfo *card = q->queuedata;
-        unsigned long flags;
-        spin_lock_irqsave(&card->lock, flags);
-        if (blk_remove_plug(q))
-                activate(card);
-        spin_unlock_irqrestore(&card->lock, flags);
-}
 /*
 * If there is room on Ready page, take
 * one bh off list and add it.
@@ -535,7 +523,6 @@ static int mm_make_request(struct request_queue *q, struct bio *bio)
        *card->biotail = bio;
        bio->bi_next = NULL;
        card->biotail = &bio->bi_next;
-        blk_plug_device(q);
        spin_unlock_irq(&card->lock);
        return 0;
@@ -897,7 +884,6 @@ static int __devinit mm_pci_probe(struct pci_dev *dev,
        blk_queue_make_request(card->queue, mm_make_request);
        card->queue->queue_lock = &card->lock;
        card->queue->queuedata = card;
-        card->queue->unplug_fn = mm_unplug_device;
        tasklet_init(&card->tasklet, process_page, (unsigned long)card);
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index e88a2cf17711..6f218e014e99 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -233,8 +233,7 @@ int ide_queue_sense_rq(ide_drive_t *drive, void *special)
        drive->hwif->rq = NULL;
-        elv_add_request(drive->queue, &drive->sense_rq,
+        elv_add_request(drive->queue, &drive->sense_rq, ELEVATOR_INSERT_FRONT);
-                        ELEVATOR_INSERT_FRONT, 0);
        return 0;
 }
 EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index a2e29099ee0c..fd1e11799137 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -258,17 +258,10 @@ static int ide_cd_breathe(ide_drive_t *drive, struct request *rq)
        if (time_after(jiffies, info->write_timeout))
                return 0;
        else {
-                struct request_queue *q = drive->queue;
-                unsigned long flags;
                /*
-                 * take a breather relying on the unplug timer to kick us again
+                 * take a breather
                 */
+                blk_delay_queue(drive->queue, 1);
-                spin_lock_irqsave(q->queue_lock, flags);
-                blk_plug_device(q);
-                spin_unlock_irqrestore(q->queue_lock, flags);
                return 1;
        }
 }
@@ -1514,8 +1507,6 @@ static int ide_cdrom_setup(ide_drive_t *drive)
        blk_queue_dma_alignment(q, 31);
        blk_queue_update_dma_pad(q, 15);
-        q->unplug_delay = max((1 * HZ) / 1000, 1);
        drive->dev_flags |= IDE_DFLAG_MEDIA_CHANGED;
        drive->atapi_flags = IDE_AFLAG_NO_EJECT | ide_cd_flags(id);
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 999dac054bcc..f4077840d3ab 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -549,8 +549,6 @@ plug_device_2:
        if (rq)
                blk_requeue_request(q, rq);
-        if (!elv_queue_empty(q))
-                blk_plug_device(q);
 }
 void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq)
@@ -562,8 +560,6 @@ void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq)
        if (rq)
                blk_requeue_request(q, rq);
-        if (!elv_queue_empty(q))
-                blk_plug_device(q);
        spin_unlock_irqrestore(q->queue_lock, flags);
 }
diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.c
index 88a380c5a470..6ab9ab2a5081 100644
--- a/drivers/ide/ide-park.c
+++ b/drivers/ide/ide-park.c
@@ -52,7 +52,7 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
        rq->cmd[0] = REQ_UNPARK_HEADS;
        rq->cmd_len = 1;
        rq->cmd_type = REQ_TYPE_SPECIAL;
-        elv_add_request(q, rq, ELEVATOR_INSERT_FRONT, 1);
+        elv_add_request(q, rq, ELEVATOR_INSERT_FRONT);
 out:
        return;
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 9a35320fb59f..ca203cb23f3c 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -347,7 +347,7 @@ static void write_page(struct bitmap *bitmap, struct page *page, int wait)
                        atomic_inc(&bitmap->pending_writes);
                        set_buffer_locked(bh);
                        set_buffer_mapped(bh);
-                        submit_bh(WRITE | REQ_UNPLUG | REQ_SYNC, bh);
+                        submit_bh(WRITE | REQ_SYNC, bh);
                        bh = bh->b_this_page;
                }
@@ -1339,8 +1339,7 @@ int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sect
                        prepare_to_wait(&bitmap->overflow_wait, &__wait,
                                        TASK_UNINTERRUPTIBLE);
                        spin_unlock_irq(&bitmap->lock);
-                        md_unplug(bitmap->mddev);
+                        io_schedule();
-                        schedule();
                        finish_wait(&bitmap->overflow_wait, &__wait);
                        continue;
                }
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 4e054bd91664..2c62c1169f78 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -991,11 +991,6 @@ static void clone_init(struct dm_crypt_io *io, struct bio *clone)
        clone->bi_destructor = dm_crypt_bio_destructor;
 }
-static void kcryptd_unplug(struct crypt_config *cc)
-{
-        blk_unplug(bdev_get_queue(cc->dev->bdev));
-}
 static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
 {
        struct crypt_config *cc = io->target->private;
@@ -1008,10 +1003,8 @@ static int kcryptd_io_read(struct dm_crypt_io *io, gfp_t gfp)
         * one in order to decrypt the whole bio data *afterwards*.
         */
        clone = bio_alloc_bioset(gfp, bio_segments(base_bio), cc->bs);
-        if (!clone) {
+        if (!clone)
-                kcryptd_unplug(cc);
                return 1;
-        }
        crypt_inc_pending(io);
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index 136d4f71a116..76a5af00a26b 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -352,7 +352,7 @@ static void dispatch_io(int rw, unsigned int num_regions,
        BUG_ON(num_regions > DM_IO_MAX_REGIONS);
        if (sync)
-                rw |= REQ_SYNC | REQ_UNPLUG;
+                rw |= REQ_SYNC;
        /*
         * For multiple regions we need to be careful to rewind
diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index 924f5f0084c2..1bb73a13ca40 100644
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -37,13 +37,6 @@ struct dm_kcopyd_client {
        unsigned int nr_pages;
        unsigned int nr_free_pages;
-        /*
-         * Block devices to unplug.
-         * Non-NULL pointer means that a block device has some pending requests
-         * and needs to be unplugged.
-         */
-        struct block_device *unplug[2];
        struct dm_io_client *io_client;
        wait_queue_head_t destroyq;
@@ -315,31 +308,6 @@ static int run_complete_job(struct kcopyd_job *job)
        return 0;
 }
-/*
- * Unplug the block device at the specified index.
- */
-static void unplug(struct dm_kcopyd_client *kc, int rw)
-{
-        if (kc->unplug[rw] != NULL) {
-                blk_unplug(bdev_get_queue(kc->unplug[rw]));
-                kc->unplug[rw] = NULL;
-        }
-}
-/*
- * Prepare block device unplug. If there's another device
- * to be unplugged at the same array index, we unplug that
- * device first.
- */
-static void prepare_unplug(struct dm_kcopyd_client *kc, int rw,
-                           struct block_device *bdev)
-{
-        if (likely(kc->unplug[rw] == bdev))
-                return;
-        unplug(kc, rw);
-        kc->unplug[rw] = bdev;
-}
 static void complete_io(unsigned long error, void *context)
 {
        struct kcopyd_job *job = (struct kcopyd_job *) context;
@@ -386,16 +354,10 @@ static int run_io_job(struct kcopyd_job *job)
                .client = job->kc->io_client,
        };
-        if (job->rw == READ) {
+        if (job->rw == READ)
                r = dm_io(&io_req, 1, &job->source, NULL);
-                prepare_unplug(job->kc, READ, job->source.bdev);
+        else
-        } else {
-                if (job->num_dests > 1)
-                        io_req.bi_rw |= REQ_UNPLUG;
                r = dm_io(&io_req, job->num_dests, job->dests, NULL);
-                if (!(io_req.bi_rw & REQ_UNPLUG))
-                        prepare_unplug(job->kc, WRITE, job->dests[0].bdev);
-        }
        return r;
 }
@@ -466,6 +428,7 @@ static void do_work(struct work_struct *work)
 {
        struct dm_kcopyd_client *kc = container_of(work,
                                        struct dm_kcopyd_client, kcopyd_work);
+        struct blk_plug plug;
        /*
         * The order that these are called is *very* important.
@@ -473,18 +436,12 @@ static void do_work(struct work_struct *work)
         * Pages jobs when successful will jump onto the io jobs
         * list.  io jobs call wake when they complete and it all
         * starts again.
-         *
-         * Note that io_jobs add block devices to the unplug array,
-         * this array is cleared with "unplug" calls. It is thus
-         * forbidden to run complete_jobs after io_jobs and before
-         * unplug because the block device could be destroyed in
-         * job completion callback.
         */
+        blk_start_plug(&plug);
        process_jobs(&kc->complete_jobs, kc, run_complete_job);
        process_jobs(&kc->pages_jobs, kc, run_pages_job);
        process_jobs(&kc->io_jobs, kc, run_io_job);
-        unplug(kc, READ);
+        blk_finish_plug(&plug);
-        unplug(kc, WRITE);
 }
 /*
@@ -665,8 +622,6 @@ int dm_kcopyd_client_create(unsigned int nr_pages,
        INIT_LIST_HEAD(&kc->io_jobs);
        INIT_LIST_HEAD(&kc->pages_jobs);
-        memset(kc->unplug, 0, sizeof(kc->unplug));
        kc->job_pool = mempool_create_slab_pool(MIN_JOBS, _job_cache);
        if (!kc->job_pool)
                goto bad_slab;
diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
index b9e1e15ef11c..5ef136cdba91 100644
--- a/drivers/md/dm-raid.c
+++ b/drivers/md/dm-raid.c
@@ -394,7 +394,7 @@ static void raid_unplug(struct dm_target_callbacks *cb)
 {
        struct raid_set *rs = container_of(cb, struct raid_set, callbacks);
-        md_raid5_unplug_device(rs->md.private);
+        md_raid5_kick_device(rs->md.private);
 }
 /*
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index dee326775c60..976ad4688afc 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -842,8 +842,6 @@ static void do_mirror(struct work_struct *work)
        do_reads(ms, &reads);
        do_writes(ms, &writes);
        do_failures(ms, &failures);
-        dm_table_unplug_all(ms->ti->table);
 }
 /*-----------------------------------------------------------------
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 38e4eb1bb965..f50a7b952257 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1275,29 +1275,6 @@ int dm_table_any_busy_target(struct dm_table *t)
        return 0;
 }
-void dm_table_unplug_all(struct dm_table *t)
-{
-        struct dm_dev_internal *dd;
-        struct list_head *devices = dm_table_get_devices(t);
-        struct dm_target_callbacks *cb;
-        list_for_each_entry(dd, devices, list) {
-                struct request_queue *q = bdev_get_queue(dd->dm_dev.bdev);
-                char b[BDEVNAME_SIZE];
-                if (likely(q))
-                        blk_unplug(q);
-                else
-                        DMWARN_LIMIT("%s: Cannot unplug nonexistent device %s",
-                                     dm_device_name(t->md),
-                                     bdevname(dd->dm_dev.bdev, b));
-        }
-        list_for_each_entry(cb, &t->target_callbacks, list)
-                if (cb->unplug_fn)
-                        cb->unplug_fn(cb);
-}
 struct mapped_device *dm_table_get_md(struct dm_table *t)
 {
        return t->md;
@@ -1345,4 +1322,3 @@ EXPORT_SYMBOL(dm_table_get_mode);
 EXPORT_SYMBOL(dm_table_get_md);
 EXPORT_SYMBOL(dm_table_put);
 EXPORT_SYMBOL(dm_table_get);
-EXPORT_SYMBOL(dm_table_unplug_all);
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index eaa3af0e0632..d22b9905c168 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -807,8 +807,6 @@ void dm_requeue_unmapped_request(struct request *clone)
        dm_unprep_request(rq);
        spin_lock_irqsave(q->queue_lock, flags);
-        if (elv_queue_empty(q))
-                blk_plug_device(q);
        blk_requeue_request(q, rq);
        spin_unlock_irqrestore(q->queue_lock, flags);
@@ -1613,10 +1611,10 @@ static void dm_request_fn(struct request_queue *q)
         * number of in-flight I/Os after the queue is stopped in
         * dm_suspend().
         */
-        while (!blk_queue_plugged(q) && !blk_queue_stopped(q)) {
+        while (!blk_queue_stopped(q)) {
                rq = blk_peek_request(q);
                if (!rq)
-                        goto plug_and_out;
+                        goto delay_and_out;
                /* always use block 0 to find the target for flushes for now */
                pos = 0;
@@ -1627,7 +1625,7 @@ static void dm_request_fn(struct request_queue *q)
                BUG_ON(!dm_target_is_valid(ti));
                if (ti->type->busy && ti->type->busy(ti))
-                        goto plug_and_out;
+                        goto delay_and_out;
                blk_start_request(rq);
                clone = rq->special;
@@ -1647,11 +1645,8 @@ requeued:
        BUG_ON(!irqs_disabled());
        spin_lock(q->queue_lock);
-plug_and_out:
+delay_and_out:
-        if (!elv_queue_empty(q))
+        blk_delay_queue(q, HZ / 10);
-                /* Some requests still remain, retry later */
-                blk_plug_device(q);
 out:
        dm_table_put(map);
@@ -1680,20 +1675,6 @@ static int dm_lld_busy(struct request_queue *q)
        return r;
 }
-static void dm_unplug_all(struct request_queue *q)
-{
-        struct mapped_device *md = q->queuedata;
-        struct dm_table *map = dm_get_live_table(md);
-        if (map) {
-                if (dm_request_based(md))
-                        generic_unplug_device(q);
-                dm_table_unplug_all(map);
-                dm_table_put(map);
-        }
-}
 static int dm_any_congested(void *congested_data, int bdi_bits)
 {
        int r = bdi_bits;
@@ -1817,7 +1798,6 @@ static void dm_init_md_queue(struct mapped_device *md)
        md->queue->backing_dev_info.congested_data = md;
        blk_queue_make_request(md->queue, dm_request);
        blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
-        md->queue->unplug_fn = dm_unplug_all;
        blk_queue_merge_bvec(md->queue, dm_merge_bvec);
        blk_queue_flush(md->queue, REQ_FLUSH | REQ_FUA);
 }
@@ -2263,8 +2243,6 @@ static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
        int r = 0;
        DECLARE_WAITQUEUE(wait, current);
-        dm_unplug_all(md->queue);
        add_wait_queue(&md->wait, &wait);
        while (1) {
@@ -2539,7 +2517,6 @@ int dm_resume(struct mapped_device *md)
        clear_bit(DMF_SUSPENDED, &md->flags);
-        dm_table_unplug_all(map);
        r = 0;
 out:
        dm_table_put(map);
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 0ed7f6bc2a7f..338804f8fb3b 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -87,22 +87,6 @@ static int linear_mergeable_bvec(struct request_queue *q,
        return maxsectors << 9;
 }
-static void linear_unplug(struct request_queue *q)
-{
-        mddev_t *mddev = q->queuedata;
-        linear_conf_t *conf;
-        int i;
-        rcu_read_lock();
-        conf = rcu_dereference(mddev->private);
-        for (i=0; i < mddev->raid_disks; i++) {
-                struct request_queue *r_queue = bdev_get_queue(conf->disks[i].rdev->bdev);
-                blk_unplug(r_queue);
-        }
-        rcu_read_unlock();
-}
 static int linear_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
@@ -224,7 +208,6 @@ static int linear_run (mddev_t *mddev)
        md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
        blk_queue_merge_bvec(mddev->queue, linear_mergeable_bvec);
-        mddev->queue->unplug_fn = linear_unplug;
        mddev->queue->backing_dev_info.congested_fn = linear_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
        md_integrity_register(mddev);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 818313e277e7..86ba66c0b28a 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -780,8 +780,7 @@ void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
        bio->bi_end_io = super_written;
        atomic_inc(&mddev->pending_writes);
-        submit_bio(REQ_WRITE | REQ_SYNC | REQ_UNPLUG | REQ_FLUSH | REQ_FUA,
+        submit_bio(REQ_WRITE | REQ_SYNC | REQ_FLUSH | REQ_FUA, bio);
-                   bio);
 }
 void md_super_wait(mddev_t *mddev)
@@ -809,7 +808,7 @@ int sync_page_io(mdk_rdev_t *rdev, sector_t sector, int size,
        struct completion event;
        int ret;
-        rw |= REQ_SYNC | REQ_UNPLUG;
+        rw |= REQ_SYNC;
        bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
                rdev->meta_bdev : rdev->bdev;
@@ -4817,7 +4816,6 @@ static int do_md_stop(mddev_t * mddev, int mode, int is_open)
                __md_stop_writes(mddev);
                md_stop(mddev);
                mddev->queue->merge_bvec_fn = NULL;
-                mddev->queue->unplug_fn = NULL;
                mddev->queue->backing_dev_info.congested_fn = NULL;
                /* tell userspace to handle 'inactive' */
@@ -6692,8 +6690,6 @@ EXPORT_SYMBOL_GPL(md_allow_write);
 void md_unplug(mddev_t *mddev)
 {
-        if (mddev->queue)
-                blk_unplug(mddev->queue);
        if (mddev->plug)
                mddev->plug->unplug_fn(mddev->plug);
 }
@@ -6876,7 +6872,6 @@ void md_do_sync(mddev_t *mddev)
                     >= mddev->resync_max - mddev->curr_resync_completed
                            )) {
                        /* time to update curr_resync_completed */
-                        md_unplug(mddev);
                        wait_event(mddev->recovery_wait,
                                   atomic_read(&mddev->recovery_active) == 0);
                        mddev->curr_resync_completed = j;
@@ -6952,7 +6947,6 @@ void md_do_sync(mddev_t *mddev)
                 * about not overloading the IO subsystem. (things like an
                 * e2fsck being done on the RAID array should execute fast)
                 */
-                md_unplug(mddev);
                cond_resched();
                currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
@@ -6971,8 +6965,6 @@ void md_do_sync(mddev_t *mddev)
         * this also signals 'finished resyncing' to md_stop
         */
 out:
-        md_unplug(mddev);
        wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
        /* tell personality that we are finished */
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 3a62d440e27b..5e694b151c30 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -106,36 +106,6 @@ static void multipath_end_request(struct bio *bio, int error)
        rdev_dec_pending(rdev, conf->mddev);
 }
-static void unplug_slaves(mddev_t *mddev)
-{
-        multipath_conf_t *conf = mddev->private;
-        int i;
-        rcu_read_lock();
-        for (i=0; i<mddev->raid_disks; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags)
-                    && atomic_read(&rdev->nr_pending)) {
-                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
-                        atomic_inc(&rdev->nr_pending);
-                        rcu_read_unlock();
-                        blk_unplug(r_queue);
-                        rdev_dec_pending(rdev, mddev);
-                        rcu_read_lock();
-                }
-        }
-        rcu_read_unlock();
-}
-static void multipath_unplug(struct request_queue *q)
-{
-        unplug_slaves(q->queuedata);
-}
 static int multipath_make_request(mddev_t *mddev, struct bio * bio)
 {
        multipath_conf_t *conf = mddev->private;
@@ -517,7 +487,6 @@ static int multipath_run (mddev_t *mddev)
         */
        md_set_array_sectors(mddev, multipath_size(mddev, 0, 0));
-        mddev->queue->unplug_fn = multipath_unplug;
        mddev->queue->backing_dev_info.congested_fn = multipath_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
        md_integrity_register(mddev);
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index c0ac457f1218..95916fd6394a 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -25,21 +25,6 @@
 #include "raid0.h"
 #include "raid5.h"
-static void raid0_unplug(struct request_queue *q)
-{
-        mddev_t *mddev = q->queuedata;
-        raid0_conf_t *conf = mddev->private;
-        mdk_rdev_t **devlist = conf->devlist;
-        int raid_disks = conf->strip_zone[0].nb_dev;
-        int i;
-        for (i=0; i < raid_disks; i++) {
-                struct request_queue *r_queue = bdev_get_queue(devlist[i]->bdev);
-                blk_unplug(r_queue);
-        }
-}
 static int raid0_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
@@ -272,7 +257,6 @@ static int create_strip_zones(mddev_t *mddev, raid0_conf_t **private_conf)
                       mdname(mddev),
                       (unsigned long long)smallest->sectors);
        }
-        mddev->queue->unplug_fn = raid0_unplug;
        mddev->queue->backing_dev_info.congested_fn = raid0_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 06cd712807d0..8f34ad5c478b 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -52,23 +52,16 @@
 #define NR_RAID1_BIOS 256
-static void unplug_slaves(mddev_t *mddev);
 static void allow_barrier(conf_t *conf);
 static void lower_barrier(conf_t *conf);
 static void * r1bio_pool_alloc(gfp_t gfp_flags, void *data)
 {
        struct pool_info *pi = data;
-        r1bio_t *r1_bio;
        int size = offsetof(r1bio_t, bios[pi->raid_disks]);
        /* allocate a r1bio with room for raid_disks entries in the bios array */
-        r1_bio = kzalloc(size, gfp_flags);
+        return kzalloc(size, gfp_flags);
-        if (!r1_bio && pi->mddev)
-                unplug_slaves(pi->mddev);
-        return r1_bio;
 }
 static void r1bio_pool_free(void *r1_bio, void *data)
@@ -91,10 +84,8 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
        int i, j;
        r1_bio = r1bio_pool_alloc(gfp_flags, pi);
-        if (!r1_bio) {
+        if (!r1_bio)
-                unplug_slaves(pi->mddev);
                return NULL;
-        }
        /*
         * Allocate bios : 1 for reading, n-1 for writing
@@ -520,37 +511,6 @@ static int read_balance(conf_t *conf, r1bio_t *r1_bio)
        return new_disk;
 }
-static void unplug_slaves(mddev_t *mddev)
-{
-        conf_t *conf = mddev->private;
-        int i;
-        rcu_read_lock();
-        for (i=0; i<mddev->raid_disks; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
-                        atomic_inc(&rdev->nr_pending);
-                        rcu_read_unlock();
-                        blk_unplug(r_queue);
-                        rdev_dec_pending(rdev, mddev);
-                        rcu_read_lock();
-                }
-        }
-        rcu_read_unlock();
-}
-static void raid1_unplug(struct request_queue *q)
-{
-        mddev_t *mddev = q->queuedata;
-        unplug_slaves(mddev);
-        md_wakeup_thread(mddev->thread);
-}
 static int raid1_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
@@ -580,23 +540,16 @@ static int raid1_congested(void *data, int bits)
 }
-static int flush_pending_writes(conf_t *conf)
+static void flush_pending_writes(conf_t *conf)
 {
        /* Any writes that have been queued but are awaiting
         * bitmap updates get flushed here.
-         * We return 1 if any requests were actually submitted.
         */
-        int rv = 0;
        spin_lock_irq(&conf->device_lock);
        if (conf->pending_bio_list.head) {
                struct bio *bio;
                bio = bio_list_get(&conf->pending_bio_list);
-                /* Only take the spinlock to quiet a warning */
-                spin_lock(conf->mddev->queue->queue_lock);
-                blk_remove_plug(conf->mddev->queue);
-                spin_unlock(conf->mddev->queue->queue_lock);
                spin_unlock_irq(&conf->device_lock);
                /* flush any pending bitmap writes to
                 * disk before proceeding w/ I/O */
@@ -608,10 +561,14 @@ static int flush_pending_writes(conf_t *conf)
                        generic_make_request(bio);
                        bio = next;
                }
-                rv = 1;
        } else
                spin_unlock_irq(&conf->device_lock);
-        return rv;
+}
+static void md_kick_device(mddev_t *mddev)
+{
+        blk_flush_plug(current);
+        md_wakeup_thread(mddev->thread);
 }
 /* Barriers....
@@ -643,8 +600,7 @@ static void raise_barrier(conf_t *conf)
        /* Wait until no block IO is waiting */
        wait_event_lock_irq(conf->wait_barrier, !conf->nr_waiting,
-                            conf->resync_lock,
+                            conf->resync_lock, md_kick_device(conf->mddev));
-                            raid1_unplug(conf->mddev->queue));
        /* block any new IO from starting */
        conf->barrier++;
@@ -652,8 +608,7 @@ static void raise_barrier(conf_t *conf)
        /* Now wait for all pending IO to complete */
        wait_event_lock_irq(conf->wait_barrier,
                            !conf->nr_pending && conf->barrier < RESYNC_DEPTH,
-                            conf->resync_lock,
+                            conf->resync_lock, md_kick_device(conf->mddev));
-                            raid1_unplug(conf->mddev->queue));
        spin_unlock_irq(&conf->resync_lock);
 }
@@ -675,7 +630,7 @@ static void wait_barrier(conf_t *conf)
                conf->nr_waiting++;
                wait_event_lock_irq(conf->wait_barrier, !conf->barrier,
                                    conf->resync_lock,
-                                    raid1_unplug(conf->mddev->queue));
+                                    md_kick_device(conf->mddev));
                conf->nr_waiting--;
        }
        conf->nr_pending++;
@@ -712,7 +667,7 @@ static void freeze_array(conf_t *conf)
                            conf->nr_pending == conf->nr_queued+1,
                            conf->resync_lock,
                            ({ flush_pending_writes(conf);
-                               raid1_unplug(conf->mddev->queue); }));
+                               md_kick_device(conf->mddev); }));
        spin_unlock_irq(&conf->resync_lock);
 }
 static void unfreeze_array(conf_t *conf)
@@ -962,7 +917,6 @@ static int make_request(mddev_t *mddev, struct bio * bio)
                atomic_inc(&r1_bio->remaining);
                spin_lock_irqsave(&conf->device_lock, flags);
                bio_list_add(&conf->pending_bio_list, mbio);
-                blk_plug_device_unlocked(mddev->queue);
                spin_unlock_irqrestore(&conf->device_lock, flags);
        }
        r1_bio_write_done(r1_bio, bio->bi_vcnt, behind_pages, behind_pages != NULL);
@@ -971,7 +925,7 @@ static int make_request(mddev_t *mddev, struct bio * bio)
        /* In case raid1d snuck in to freeze_array */
        wake_up(&conf->wait_barrier);
-        if (do_sync)
+        if (do_sync || !bitmap)
                md_wakeup_thread(mddev->thread);
        return 0;
@@ -1561,7 +1515,6 @@ static void raid1d(mddev_t *mddev)
        unsigned long flags;
        conf_t *conf = mddev->private;
        struct list_head *head = &conf->retry_list;
-        int unplug=0;
        mdk_rdev_t *rdev;
        md_check_recovery(mddev);
@@ -1569,7 +1522,7 @@ static void raid1d(mddev_t *mddev)
        for (;;) {
                char b[BDEVNAME_SIZE];
-                unplug += flush_pending_writes(conf);
+                flush_pending_writes(conf);
                spin_lock_irqsave(&conf->device_lock, flags);
                if (list_empty(head)) {
@@ -1583,10 +1536,9 @@ static void raid1d(mddev_t *mddev)
                mddev = r1_bio->mddev;
                conf = mddev->private;
-                if (test_bit(R1BIO_IsSync, &r1_bio->state)) {
+                if (test_bit(R1BIO_IsSync, &r1_bio->state))
                        sync_request_write(mddev, r1_bio);
-                        unplug = 1;
+                else {
-                } else {
                        int disk;
                        /* we got a read error. Maybe the drive is bad.  Maybe just
@@ -1636,14 +1588,11 @@ static void raid1d(mddev_t *mddev)
                                bio->bi_end_io = raid1_end_read_request;
                                bio->bi_rw = READ | do_sync;
                                bio->bi_private = r1_bio;
-                                unplug = 1;
                                generic_make_request(bio);
                        }
                }
                cond_resched();
        }
-        if (unplug)
-                unplug_slaves(mddev);
 }
@@ -2066,7 +2015,6 @@ static int run(mddev_t *mddev)
        md_set_array_sectors(mddev, raid1_size(mddev, 0, 0));
-        mddev->queue->unplug_fn = raid1_unplug;
        mddev->queue->backing_dev_info.congested_fn = raid1_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
        md_integrity_register(mddev);
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 747d061d8e05..c0d0f5f7e407 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -57,23 +57,16 @@
 */
 #define NR_RAID10_BIOS 256
-static void unplug_slaves(mddev_t *mddev);
 static void allow_barrier(conf_t *conf);
 static void lower_barrier(conf_t *conf);
 static void * r10bio_pool_alloc(gfp_t gfp_flags, void *data)
 {
        conf_t *conf = data;
-        r10bio_t *r10_bio;
        int size = offsetof(struct r10bio_s, devs[conf->copies]);
        /* allocate a r10bio with room for raid_disks entries in the bios array */
-        r10_bio = kzalloc(size, gfp_flags);
+        return kzalloc(size, gfp_flags);
-        if (!r10_bio && conf->mddev)
-                unplug_slaves(conf->mddev);
-        return r10_bio;
 }
 static void r10bio_pool_free(void *r10_bio, void *data)
@@ -106,10 +99,8 @@ static void * r10buf_pool_alloc(gfp_t gfp_flags, void *data)
        int nalloc;
        r10_bio = r10bio_pool_alloc(gfp_flags, conf);
-        if (!r10_bio) {
+        if (!r10_bio)
-                unplug_slaves(conf->mddev);
                return NULL;
-        }
        if (test_bit(MD_RECOVERY_SYNC, &conf->mddev->recovery))
                nalloc = conf->copies; /* resync */
@@ -597,37 +588,6 @@ rb_out:
        return disk;
 }
-static void unplug_slaves(mddev_t *mddev)
-{
-        conf_t *conf = mddev->private;
-        int i;
-        rcu_read_lock();
-        for (i=0; i < conf->raid_disks; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
-                        atomic_inc(&rdev->nr_pending);
-                        rcu_read_unlock();
-                        blk_unplug(r_queue);
-                        rdev_dec_pending(rdev, mddev);
-                        rcu_read_lock();
-                }
-        }
-        rcu_read_unlock();
-}
-static void raid10_unplug(struct request_queue *q)
-{
-        mddev_t *mddev = q->queuedata;
-        unplug_slaves(q->queuedata);
-        md_wakeup_thread(mddev->thread);
-}
 static int raid10_congested(void *data, int bits)
 {
        mddev_t *mddev = data;
@@ -649,23 +609,16 @@ static int raid10_congested(void *data, int bits)
        return ret;
 }
-static int flush_pending_writes(conf_t *conf)
+static void flush_pending_writes(conf_t *conf)
 {
        /* Any writes that have been queued but are awaiting
         * bitmap updates get flushed here.
-         * We return 1 if any requests were actually submitted.
         */
-        int rv = 0;
        spin_lock_irq(&conf->device_lock);
        if (conf->pending_bio_list.head) {
                struct bio *bio;
                bio = bio_list_get(&conf->pending_bio_list);
-                /* Spinlock only taken to quiet a warning */
-                spin_lock(conf->mddev->queue->queue_lock);
-                blk_remove_plug(conf->mddev->queue);
-                spin_unlock(conf->mddev->queue->queue_lock);
                spin_unlock_irq(&conf->device_lock);
                /* flush any pending bitmap writes to disk
                 * before proceeding w/ I/O */
@@ -677,11 +630,16 @@ static int flush_pending_writes(conf_t *conf)
                        generic_make_request(bio);
                        bio = next;
                }
-                rv = 1;
        } else
                spin_unlock_irq(&conf->device_lock);
-        return rv;
 }
+static void md_kick_device(mddev_t *mddev)
+{
+        blk_flush_plug(current);
+        md_wakeup_thread(mddev->thread);
+}
 /* Barriers....
 * Sometimes we need to suspend IO while we do something else,
 * either some resync/recovery, or reconfigure the array.
@@ -711,8 +669,7 @@ static void raise_barrier(conf_t *conf, int force)
        /* Wait until no block IO is waiting (unless 'force') */
        wait_event_lock_irq(conf->wait_barrier, force || !conf->nr_waiting,
-                            conf->resync_lock,
+                            conf->resync_lock, md_kick_device(conf->mddev));
-                            raid10_unplug(conf->mddev->queue));
        /* block any new IO from starting */
        conf->barrier++;
@@ -720,8 +677,7 @@ static void raise_barrier(conf_t *conf, int force)
        /* No wait for all pending IO to complete */
        wait_event_lock_irq(conf->wait_barrier,
                            !conf->nr_pending && conf->barrier < RESYNC_DEPTH,
-                            conf->resync_lock,
+                            conf->resync_lock, md_kick_device(conf->mddev));
-                            raid10_unplug(conf->mddev->queue));
        spin_unlock_irq(&conf->resync_lock);
 }
@@ -742,7 +698,7 @@ static void wait_barrier(conf_t *conf)
                conf->nr_waiting++;
                wait_event_lock_irq(conf->wait_barrier, !conf->barrier,
                                    conf->resync_lock,
-                                    raid10_unplug(conf->mddev->queue));
+                                    md_kick_device(conf->mddev));
                conf->nr_waiting--;
        }
        conf->nr_pending++;
@@ -779,7 +735,7 @@ static void freeze_array(conf_t *conf)
                            conf->nr_pending == conf->nr_queued+1,
                            conf->resync_lock,
                            ({ flush_pending_writes(conf);
-                               raid10_unplug(conf->mddev->queue); }));
+                               md_kick_device(conf->mddev); }));
        spin_unlock_irq(&conf->resync_lock);
 }
@@ -974,7 +930,6 @@ static int make_request(mddev_t *mddev, struct bio * bio)
                atomic_inc(&r10_bio->remaining);
                spin_lock_irqsave(&conf->device_lock, flags);
                bio_list_add(&conf->pending_bio_list, mbio);
-                blk_plug_device_unlocked(mddev->queue);
                spin_unlock_irqrestore(&conf->device_lock, flags);
        }
@@ -991,7 +946,7 @@ static int make_request(mddev_t *mddev, struct bio * bio)
        /* In case raid10d snuck in to freeze_array */
        wake_up(&conf->wait_barrier);
-        if (do_sync)
+        if (do_sync || !mddev->bitmap)
                md_wakeup_thread(mddev->thread);
        return 0;
@@ -1684,7 +1639,6 @@ static void raid10d(mddev_t *mddev)
        unsigned long flags;
        conf_t *conf = mddev->private;
        struct list_head *head = &conf->retry_list;
-        int unplug=0;
        mdk_rdev_t *rdev;
        md_check_recovery(mddev);
@@ -1692,7 +1646,7 @@ static void raid10d(mddev_t *mddev)
        for (;;) {
                char b[BDEVNAME_SIZE];
-                unplug += flush_pending_writes(conf);
+                flush_pending_writes(conf);
                spin_lock_irqsave(&conf->device_lock, flags);
                if (list_empty(head)) {
@@ -1706,13 +1660,11 @@ static void raid10d(mddev_t *mddev)
                mddev = r10_bio->mddev;
                conf = mddev->private;
-                if (test_bit(R10BIO_IsSync, &r10_bio->state)) {
+                if (test_bit(R10BIO_IsSync, &r10_bio->state))
                        sync_request_write(mddev, r10_bio);
-                        unplug = 1;
+                else if (test_bit(R10BIO_IsRecover, &r10_bio->state))
-                } else  if (test_bit(R10BIO_IsRecover, &r10_bio->state)) {
                        recovery_request_write(mddev, r10_bio);
-                        unplug = 1;
+                else {
-                } else {
                        int mirror;
                        /* we got a read error. Maybe the drive is bad.  Maybe just
                         * the block and we can fix it.
@@ -1759,14 +1711,11 @@ static void raid10d(mddev_t *mddev)
                                bio->bi_rw = READ | do_sync;
                                bio->bi_private = r10_bio;
                                bio->bi_end_io = raid10_end_read_request;
-                                unplug = 1;
                                generic_make_request(bio);
                        }
                }
                cond_resched();
        }
-        if (unplug)
-                unplug_slaves(mddev);
 }
@@ -2377,7 +2326,6 @@ static int run(mddev_t *mddev)
        md_set_array_sectors(mddev, size);
        mddev->resync_max_sectors = size;
-        mddev->queue->unplug_fn = raid10_unplug;
        mddev->queue->backing_dev_info.congested_fn = raid10_congested;
        mddev->queue->backing_dev_info.congested_data = mddev;
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 78536fdbd87f..e867ee42b152 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -433,8 +433,6 @@ static int has_failed(raid5_conf_t *conf)
        return 0;
 }
-static void unplug_slaves(mddev_t *mddev);
 static struct stripe_head *
 get_active_stripe(raid5_conf_t *conf, sector_t sector,
                  int previous, int noblock, int noquiesce)
@@ -463,8 +461,7 @@ get_active_stripe(raid5_conf_t *conf, sector_t sector,
                                                     < (conf->max_nr_stripes *3/4)
                                                     || !conf->inactive_blocked),
                                                    conf->device_lock,
-                                                    md_raid5_unplug_device(conf)
+                                                    md_raid5_kick_device(conf));
-                                        );
                                conf->inactive_blocked = 0;
                        } else
                                init_stripe(sh, sector, previous);
@@ -1473,8 +1470,7 @@ static int resize_stripes(raid5_conf_t *conf, int newsize)
                wait_event_lock_irq(conf->wait_for_stripe,
                                    !list_empty(&conf->inactive_list),
                                    conf->device_lock,
-                                    unplug_slaves(conf->mddev)
+                                    blk_flush_plug(current));
-                        );
                osh = get_free_stripe(conf);
                spin_unlock_irq(&conf->device_lock);
                atomic_set(&nsh->count, 1);
@@ -3645,58 +3641,19 @@ static void activate_bit_delay(raid5_conf_t *conf)
        }
 }
-static void unplug_slaves(mddev_t *mddev)
+void md_raid5_kick_device(raid5_conf_t *conf)
 {
-        raid5_conf_t *conf = mddev->private;
+        blk_flush_plug(current);
-        int i;
+        raid5_activate_delayed(conf);
-        int devs = max(conf->raid_disks, conf->previous_raid_disks);
-        rcu_read_lock();
-        for (i = 0; i < devs; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->disks[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
-                        atomic_inc(&rdev->nr_pending);
-                        rcu_read_unlock();
-                        blk_unplug(r_queue);
-                        rdev_dec_pending(rdev, mddev);
-                        rcu_read_lock();
-                }
-        }
-        rcu_read_unlock();
-}
-void md_raid5_unplug_device(raid5_conf_t *conf)
-{
-        unsigned long flags;
-        spin_lock_irqsave(&conf->device_lock, flags);
-        if (plugger_remove_plug(&conf->plug)) {
-                conf->seq_flush++;
-                raid5_activate_delayed(conf);
-        }
        md_wakeup_thread(conf->mddev->thread);
-        spin_unlock_irqrestore(&conf->device_lock, flags);
-        unplug_slaves(conf->mddev);
 }
-EXPORT_SYMBOL_GPL(md_raid5_unplug_device);
+EXPORT_SYMBOL_GPL(md_raid5_kick_device);
 static void raid5_unplug(struct plug_handle *plug)
 {
        raid5_conf_t *conf = container_of(plug, raid5_conf_t, plug);
-        md_raid5_unplug_device(conf);
-}
-static void raid5_unplug_queue(struct request_queue *q)
+        md_raid5_kick_device(conf);
-{
-        mddev_t *mddev = q->queuedata;
-        md_raid5_unplug_device(mddev->private);
 }
 int md_raid5_congested(mddev_t *mddev, int bits)
@@ -4100,7 +4057,7 @@ static int make_request(mddev_t *mddev, struct bio * bi)
                                 * add failed due to overlap.  Flush everything
                                 * and wait a while
                                 */
-                                md_raid5_unplug_device(conf);
+                                md_raid5_kick_device(conf);
                                release_stripe(sh);
                                schedule();
                                goto retry;
@@ -4365,7 +4322,6 @@ static inline sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *ski
        if (sector_nr >= max_sector) {
                /* just being told to finish up .. nothing much to do */
-                unplug_slaves(mddev);
                if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
                        end_reshape(conf);
@@ -4569,7 +4525,6 @@ static void raid5d(mddev_t *mddev)
        spin_unlock_irq(&conf->device_lock);
        async_tx_issue_pending_all();
-        unplug_slaves(mddev);
        pr_debug("--- raid5d inactive\n");
 }
@@ -5204,7 +5159,7 @@ static int run(mddev_t *mddev)
                mddev->queue->backing_dev_info.congested_data = mddev;
                mddev->queue->backing_dev_info.congested_fn = raid5_congested;
-                mddev->queue->unplug_fn = raid5_unplug_queue;
+                mddev->queue->queue_lock = &conf->device_lock;
                chunk_size = mddev->chunk_sectors << 9;
                blk_queue_io_min(mddev->queue, chunk_size);
diff --git a/drivers/md/raid5.h b/drivers/md/raid5.h
index 2ace0582b409..8d563a4f022a 100644
--- a/drivers/md/raid5.h
+++ b/drivers/md/raid5.h
@@ -503,6 +503,6 @@ static inline int algorithm_is_DDF(int layout)
 }
 extern int md_raid5_congested(mddev_t *mddev, int bits);
-extern void md_raid5_unplug_device(raid5_conf_t *conf);
+extern void md_raid5_kick_device(raid5_conf_t *conf);
 extern int raid5_set_cache_size(mddev_t *mddev, int size);
 #endif
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index f81c25d4a125..47ec5bc0ed21 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -897,11 +897,7 @@ static void i2o_block_request_fn(struct request_queue *q)
 {
        struct request *req;
-        while (!blk_queue_plugged(q)) {
+        while ((req = blk_peek_request(q)) != NULL) {
-                req = blk_peek_request(q);
-                if (!req)
-                        break;
                if (req->cmd_type == REQ_TYPE_FS) {
                        struct i2o_block_delayed_request *dreq;
                        struct i2o_block_request *ireq = req->special;
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 4e42d030e097..2ae727568df9 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -55,8 +55,7 @@ static int mmc_queue_thread(void *d)
                spin_lock_irq(q->queue_lock);
                set_current_state(TASK_INTERRUPTIBLE);
-                if (!blk_queue_plugged(q))
+                req = blk_fetch_request(q);
-                        req = blk_fetch_request(q);
                mq->req = req;
                spin_unlock_irq(q->queue_lock);
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 794bfd962266..4d2df2f76ea0 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -1917,7 +1917,7 @@ static void __dasd_process_request_queue(struct dasd_block *block)
                return;
        }
        /* Now we try to fetch requests from the request queue */
-        while (!blk_queue_plugged(queue) && (req = blk_peek_request(queue))) {
+        while ((req = blk_peek_request(queue))) {
                if (basedev->features & DASD_FEATURE_READONLY &&
                    rq_data_dir(req) == WRITE) {
                        DBF_DEV_EVENT(DBF_ERR, basedev,
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index ad8431636012..83cea9a55e2f 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -161,7 +161,6 @@ tapeblock_requeue(struct work_struct *work) {
        spin_lock_irq(&device->blk_data.request_queue_lock);
        while (
-                !blk_queue_plugged(queue) &&
                blk_peek_request(queue) &&
                nr_queued < TAPEBLOCK_MIN_REQUEUE
        ) {
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index fb2bb35c62cb..bf80a4c5a481 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -67,6 +67,13 @@ static struct scsi_host_sg_pool scsi_sg_pools[] = {
 struct kmem_cache *scsi_sdb_cache;
+/*
+ * When to reinvoke queueing after a resource shortage. It's 3 msecs to
+ * not change behaviour from the previous unplug mechanism, experimentation
+ * may prove this needs changing.
+ */
+#define SCSI_QUEUE_DELAY        3
 static void scsi_run_queue(struct request_queue *q);
 /*
@@ -149,14 +156,7 @@ static int __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy)
        /*
         * Requeue this command.  It will go before all other commands
         * that are already in the queue.
-         *
+         */
-         * NOTE: there is magic here about the way the queue is plugged if
-         * we have no outstanding commands.
-         * 
-         * Although we *don't* plug the queue, we call the request
-         * function.  The SCSI request function detects the blocked condition
-         * and plugs the queue appropriately.
-         */
        spin_lock_irqsave(q->queue_lock, flags);
        blk_requeue_request(q, cmd->request);
        spin_unlock_irqrestore(q->queue_lock, flags);
@@ -1194,11 +1194,11 @@ int scsi_prep_return(struct request_queue *q, struct request *req, int ret)
        case BLKPREP_DEFER:
                /*
                 * If we defer, the blk_peek_request() returns NULL, but the
-                 * queue must be restarted, so we plug here if no returning
+                 * queue must be restarted, so we schedule a callback to happen
-                 * command will automatically do that.
+                 * shortly.
                 */
                if (sdev->device_busy == 0)
-                        blk_plug_device(q);
+                        blk_delay_queue(q, SCSI_QUEUE_DELAY);
                break;
        default:
                req->cmd_flags |= REQ_DONTPREP;
@@ -1237,7 +1237,7 @@ static inline int scsi_dev_queue_ready(struct request_queue *q,
                                   sdev_printk(KERN_INFO, sdev,
                                   "unblocking device at zero depth\n"));
                } else {
-                        blk_plug_device(q);
+                        blk_delay_queue(q, SCSI_QUEUE_DELAY);
                        return 0;
                }
        }
@@ -1467,7 +1467,7 @@ static void scsi_request_fn(struct request_queue *q)
         * the host is no longer able to accept any more requests.
         */
        shost = sdev->host;
-        while (!blk_queue_plugged(q)) {
+        for (;;) {
                int rtn;
                /*
                 * get next queueable request.  We do this early to make sure
@@ -1546,15 +1546,8 @@ static void scsi_request_fn(struct request_queue *q)
                 */
                rtn = scsi_dispatch_cmd(cmd);
                spin_lock_irq(q->queue_lock);
-                if(rtn) {
+                if (rtn)
-                        /* we're refusing the command; because of
+                        goto out_delay;
-                         * the way locks get dropped, we need to 
-                         * check here if plugging is required */
-                        if(sdev->device_busy == 0)
-                                blk_plug_device(q);
-                        break;
-                }
        }
        goto out;
@@ -1573,9 +1566,10 @@ static void scsi_request_fn(struct request_queue *q)
        spin_lock_irq(q->queue_lock);
        blk_requeue_request(q, req);
        sdev->device_busy--;
-        if(sdev->device_busy == 0)
+out_delay:
-                blk_plug_device(q);
+        if (sdev->device_busy == 0)
- out:
+                blk_delay_queue(q, SCSI_QUEUE_DELAY);
+out:
        /* must be careful here...if we trigger the ->remove() function
         * we cannot be holding the q lock */
        spin_unlock_irq(q->queue_lock);
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 5c3ccfc6b622..2941d2d92c94 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -3913,7 +3913,7 @@ fc_bsg_request_handler(struct request_queue *q, struct Scsi_Host *shost,
        if (!get_device(dev))
                return;
-        while (!blk_queue_plugged(q)) {
+        while (1) {
                if (rport && (rport->port_state == FC_PORTSTATE_BLOCKED) &&
                    !(rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT))
                        break;
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index 927e99cb7225..c6fcf76cade5 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -173,11 +173,7 @@ static void sas_smp_request(struct request_queue *q, struct Scsi_Host *shost,
        int ret;
        int (*handler)(struct Scsi_Host *, struct sas_rphy *, struct request *);
-        while (!blk_queue_plugged(q)) {
+        while ((req = blk_fetch_request(q)) != NULL) {
-                req = blk_fetch_request(q);
-                if (!req)
-                        break;
                spin_unlock_irq(q->queue_lock);
                handler = to_sas_internal(shost->transportt)->f->smp_handler;
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 67f0c09983c8..c1b539d7b0d3 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -392,9 +392,8 @@ static int iblock_do_task(struct se_task *task)
 {
        struct se_device *dev = task->task_se_cmd->se_dev;
        struct iblock_req *req = IBLOCK_REQ(task);
-        struct iblock_dev *ibd = (struct iblock_dev *)req->ib_dev;
-        struct request_queue *q = bdev_get_queue(ibd->ibd_bd);
        struct bio *bio = req->ib_bio, *nbio = NULL;
+        struct blk_plug plug;
        int rw;
        if (task->task_data_direction == DMA_TO_DEVICE) {
@@ -412,6 +411,7 @@ static int iblock_do_task(struct se_task *task)
                rw = READ;
        }
+        blk_start_plug(&plug);
        while (bio) {
                nbio = bio->bi_next;
                bio->bi_next = NULL;
@@ -421,9 +421,8 @@ static int iblock_do_task(struct se_task *task)
                submit_bio(rw, bio);
                bio = nbio;
        }
+        blk_finish_plug(&plug);
-        if (q->unplug_fn)
-                q->unplug_fn(q);
        return PYX_TRANSPORT_SENT_TO_TRANSPORT;
 }