60 files changed, 284 insertions, 721 deletions

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 1f286ab461d3..79882104e431 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -140,13 +140,14 @@ static int DAC960_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return 0;
 }
 
-static int DAC960_media_changed(struct gendisk *disk)
+static unsigned int DAC960_check_events(struct gendisk *disk,
+                                        unsigned int clearing)
 {
         DAC960_Controller_T *p = disk->queue->queuedata;
         int drive_nr = (long)disk->private_data;
 
         if (!p->LogicalDriveInitiallyAccessible[drive_nr])
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
         return 0;
 }
 
@@ -163,7 +164,7 @@ static const struct block_device_operations DAC960_BlockDeviceOperations = {
         .owner                  = THIS_MODULE,
         .open                   = DAC960_open,
         .getgeo                 = DAC960_getgeo,
-        .media_changed          = DAC960_media_changed,
+        .check_events           = DAC960_check_events,
         .revalidate_disk        = DAC960_revalidate_disk,
 };
 
@@ -2546,6 +2547,7 @@ static bool DAC960_RegisterBlockDevice(DAC960_Controller_T *Controller)
         disk->major = MajorNumber;
         disk->first_minor = n << DAC960_MaxPartitionsBits;
         disk->fops = &DAC960_BlockDeviceOperations;
+        disk->events = DISK_EVENT_MEDIA_CHANGE;
    }
   /*
     Indicate the Block Device Registration completed successfully,
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 363855ca376e..456c0cc90dcf 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -1658,12 +1658,12 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
 }
 
 /*
- * floppy-change is never called from an interrupt, so we can relax a bit
+ * check_events is never called from an interrupt, so we can relax a bit
  * here, sleep etc. Note that floppy-on tries to set current_DOR to point
  * to the desired drive, but it will probably not survive the sleep if
  * several floppies are used at the same time: thus the loop.
  */
-static int amiga_floppy_change(struct gendisk *disk)
+static unsigned amiga_check_events(struct gendisk *disk, unsigned int clearing)
 {
         struct amiga_floppy_struct *p = disk->private_data;
         int drive = p - unit;
@@ -1686,7 +1686,7 @@ static int amiga_floppy_change(struct gendisk *disk)
                 p->dirty = 0;
                 writepending = 0; /* if this was true before, too bad! */
                 writefromint = 0;
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
         }
         return 0;
 }
@@ -1697,7 +1697,7 @@ static const struct block_device_operations floppy_fops = {
         .release        = floppy_release,
         .ioctl          = fd_ioctl,
         .getgeo         = fd_getgeo,
-        .media_changed  = amiga_floppy_change,
+        .check_events   = amiga_check_events,
 };
 
 static int __init fd_probe_drives(void)
@@ -1736,6 +1736,7 @@ static int __init fd_probe_drives(void)
                 disk->major = FLOPPY_MAJOR;
                 disk->first_minor = drive;
                 disk->fops = &floppy_fops;
+                disk->events = DISK_EVENT_MEDIA_CHANGE;
                 sprintf(disk->disk_name, "fd%d", drive);
                 disk->private_data = &unit[drive];
                 set_capacity(disk, 880*2);
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index 605a67e40bbf..c871eae14120 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -1324,23 +1324,24 @@ static void finish_fdc_done( int dummy )
  * due to unrecognised disk changes.
  */
 
-static int check_floppy_change(struct gendisk *disk)
+static unsigned int floppy_check_events(struct gendisk *disk,
+                                        unsigned int clearing)
 {
         struct atari_floppy_struct *p = disk->private_data;
         unsigned int drive = p - unit;
         if (test_bit (drive, &fake_change)) {
                 /* simulated change (e.g. after formatting) */
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
         }
         if (test_bit (drive, &changed_floppies)) {
                 /* surely changed (the WP signal changed at least once) */
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
         }
         if (UD.wpstat) {
                 /* WP is on -> could be changed: to be sure, buffers should be
                  * invalidated...
                  */
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
         }
 
         return 0;
@@ -1570,7 +1571,7 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode,
                  * or the next access will revalidate - and clear UDT :-(
                  */
 
-                if (check_floppy_change(disk))
+                if (floppy_check_events(disk, 0))
                         floppy_revalidate(disk);
 
                 if (UD.flags & FTD_MSG)
@@ -1904,7 +1905,7 @@ static const struct block_device_operations floppy_fops = {
         .open           = floppy_unlocked_open,
         .release        = floppy_release,
         .ioctl          = fd_ioctl,
-        .media_changed  = check_floppy_change,
+        .check_events   = floppy_check_events,
         .revalidate_disk= floppy_revalidate,
 };
 
@@ -1963,6 +1964,7 @@ static int __init atari_floppy_init (void)
                 unit[i].disk->first_minor = i;
                 sprintf(unit[i].disk->disk_name, "fd%d", i);
                 unit[i].disk->fops = &floppy_fops;
+                unit[i].disk->events = DISK_EVENT_MEDIA_CHANGE;
                 unit[i].disk->private_data = &unit[i];
                 unit[i].disk->queue = blk_init_queue(do_fd_request,
                                         &ataflop_lock);
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 */
-                /* plugging on a queue, that actually has no requests! */
-        q->unplug_fn = drbd_unplug_fn;
+        q->queue_lock = &mdev->req_lock;
 
         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);
-                schedule();
+                io_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 77fc76f8aea9..301d7a9a41a6 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -3770,13 +3770,14 @@ out2:
 /*
  * Check if the disk has been changed or if a change has been faked.
  */
-static int check_floppy_change(struct gendisk *disk)
+static unsigned int floppy_check_events(struct gendisk *disk,
+                                        unsigned int clearing)
 {
         int drive = (long)disk->private_data;
 
         if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
             test_bit(FD_VERIFY_BIT, &UDRS->flags))
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
 
         if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
                 lock_fdc(drive, false);
@@ -3788,7 +3789,7 @@ static int check_floppy_change(struct gendisk *disk)
             test_bit(FD_VERIFY_BIT, &UDRS->flags) ||
             test_bit(drive, &fake_change) ||
             drive_no_geom(drive))
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
         return 0;
 }
 
@@ -3837,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);
 
@@ -3898,7 +3898,7 @@ static const struct block_device_operations floppy_fops = {
         .release                = floppy_release,
         .ioctl                  = fd_ioctl,
         .getgeo                 = fd_getgeo,
-        .media_changed          = check_floppy_change,
+        .check_events           = floppy_check_events,
         .revalidate_disk        = floppy_revalidate,
 };
 
@@ -4205,6 +4205,7 @@ static int __init floppy_init(void)
                 disks[dr]->major = FLOPPY_MAJOR;
                 disks[dr]->first_minor = TOMINOR(dr);
                 disks[dr]->fops = &floppy_fops;
+                disks[dr]->events = DISK_EVENT_MEDIA_CHANGE;
                 sprintf(disks[dr]->disk_name, "fd%d", dr);
 
                 init_timer(&motor_off_timer[dr]);
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index dbf31ec9114d..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);
@@ -1636,9 +1623,6 @@ out:
 
 static void loop_free(struct loop_device *lo)
 {
-        if (!lo->lo_queue->queue_lock)
-                lo->lo_queue->queue_lock = &lo->lo_queue->__queue_lock;
-
         blk_cleanup_queue(lo->lo_queue);
         put_disk(lo->lo_disk);
         list_del(&lo->lo_list);
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index 62cec6afd7ad..2f2ccf686251 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -172,7 +172,8 @@ module_param_array(drive3, int, NULL, 0);
 static int pcd_open(struct cdrom_device_info *cdi, int purpose);
 static void pcd_release(struct cdrom_device_info *cdi);
 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
-static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr);
+static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
+                                     unsigned int clearing, int slot_nr);
 static int pcd_tray_move(struct cdrom_device_info *cdi, int position);
 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock);
 static int pcd_drive_reset(struct cdrom_device_info *cdi);
@@ -257,10 +258,11 @@ static int pcd_block_ioctl(struct block_device *bdev, fmode_t mode,
         return ret;
 }
 
-static int pcd_block_media_changed(struct gendisk *disk)
+static unsigned int pcd_block_check_events(struct gendisk *disk,
+                                           unsigned int clearing)
 {
         struct pcd_unit *cd = disk->private_data;
-        return cdrom_media_changed(&cd->info);
+        return cdrom_check_events(&cd->info, clearing);
 }
 
 static const struct block_device_operations pcd_bdops = {
@@ -268,14 +270,14 @@ static const struct block_device_operations pcd_bdops = {
         .open           = pcd_block_open,
         .release        = pcd_block_release,
         .ioctl          = pcd_block_ioctl,
-        .media_changed  = pcd_block_media_changed,
+        .check_events   = pcd_block_check_events,
 };
 
 static struct cdrom_device_ops pcd_dops = {
         .open           = pcd_open,
         .release        = pcd_release,
         .drive_status   = pcd_drive_status,
-        .media_changed  = pcd_media_changed,
+        .check_events   = pcd_check_events,
         .tray_move      = pcd_tray_move,
         .lock_door      = pcd_lock_door,
         .get_mcn        = pcd_get_mcn,
@@ -318,6 +320,7 @@ static void pcd_init_units(void)
                 disk->first_minor = unit;
                 strcpy(disk->disk_name, cd->name);      /* umm... */
                 disk->fops = &pcd_bdops;
+                disk->events = DISK_EVENT_MEDIA_CHANGE;
         }
 }
 
@@ -502,13 +505,14 @@ static int pcd_packet(struct cdrom_device_info *cdi, struct packet_command *cgc)
 
 #define DBMSG(msg)      ((verbose>1)?(msg):NULL)
 
-static int pcd_media_changed(struct cdrom_device_info *cdi, int slot_nr)
+static unsigned int pcd_check_events(struct cdrom_device_info *cdi,
+                                     unsigned int clearing, int slot_nr)
 {
         struct pcd_unit *cd = cdi->handle;
         int res = cd->changed;
         if (res)
                 cd->changed = 0;
-        return res;
+        return res ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 static int pcd_lock_door(struct cdrom_device_info *cdi, int lock)
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index c0ee1558b9bb..21dfdb776869 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -794,7 +794,7 @@ static int pd_release(struct gendisk *p, fmode_t mode)
         return 0;
 }
 
-static int pd_check_media(struct gendisk *p)
+static unsigned int pd_check_events(struct gendisk *p, unsigned int clearing)
 {
         struct pd_unit *disk = p->private_data;
         int r;
@@ -803,7 +803,7 @@ static int pd_check_media(struct gendisk *p)
         pd_special_command(disk, pd_media_check);
         r = disk->changed;
         disk->changed = 0;
-        return r;
+        return r ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 static int pd_revalidate(struct gendisk *p)
@@ -822,7 +822,7 @@ static const struct block_device_operations pd_fops = {
         .release        = pd_release,
         .ioctl          = pd_ioctl,
         .getgeo         = pd_getgeo,
-        .media_changed  = pd_check_media,
+        .check_events   = pd_check_events,
         .revalidate_disk= pd_revalidate
 };
 
@@ -837,6 +837,7 @@ static void pd_probe_drive(struct pd_unit *disk)
         p->fops = &pd_fops;
         p->major = major;
         p->first_minor = (disk - pd) << PD_BITS;
+        p->events = DISK_EVENT_MEDIA_CHANGE;
         disk->gd = p;
         p->private_data = disk;
         p->queue = pd_queue;
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 635f25dd9e10..7adeb1edbf43 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -243,7 +243,8 @@ static struct pf_unit units[PF_UNITS];
 static int pf_identify(struct pf_unit *pf);
 static void pf_lock(struct pf_unit *pf, int func);
 static void pf_eject(struct pf_unit *pf);
-static int pf_check_media(struct gendisk *disk);
+static unsigned int pf_check_events(struct gendisk *disk,
+                                    unsigned int clearing);
 
 static char pf_scratch[512];    /* scratch block buffer */
 
@@ -270,7 +271,7 @@ static const struct block_device_operations pf_fops = {
         .release        = pf_release,
         .ioctl          = pf_ioctl,
         .getgeo         = pf_getgeo,
-        .media_changed  = pf_check_media,
+        .check_events   = pf_check_events,
 };
 
 static void __init pf_init_units(void)
@@ -293,6 +294,7 @@ static void __init pf_init_units(void)
                 disk->first_minor = unit;
                 strcpy(disk->disk_name, pf->name);
                 disk->fops = &pf_fops;
+                disk->events = DISK_EVENT_MEDIA_CHANGE;
                 if (!(*drives[unit])[D_PRT])
                         pf_drive_count++;
         }
@@ -377,9 +379,9 @@ static int pf_release(struct gendisk *disk, fmode_t mode)
 
 }
 
-static int pf_check_media(struct gendisk *disk)
+static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
 {
-        return 1;
+        return DISK_EVENT_MEDIA_CHANGE;
 }
 
 static inline int status_reg(struct pf_unit *pf)
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 77d70eebb6b2..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");
@@ -2796,7 +2794,8 @@ static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
         return ret;
 }
 
-static int pkt_media_changed(struct gendisk *disk)
+static unsigned int pkt_check_events(struct gendisk *disk,
+                                     unsigned int clearing)
 {
         struct pktcdvd_device *pd = disk->private_data;
         struct gendisk *attached_disk;
@@ -2806,9 +2805,9 @@ static int pkt_media_changed(struct gendisk *disk)
         if (!pd->bdev)
                 return 0;
         attached_disk = pd->bdev->bd_disk;
-        if (!attached_disk)
+        if (!attached_disk || !attached_disk->fops->check_events)
                 return 0;
-        return attached_disk->fops->media_changed(attached_disk);
+        return attached_disk->fops->check_events(attached_disk, clearing);
 }
 
 static const struct block_device_operations pktcdvd_ops = {
@@ -2816,7 +2815,7 @@ static const struct block_device_operations pktcdvd_ops = {
         .open =                 pkt_open,
         .release =              pkt_close,
         .ioctl =                pkt_ioctl,
-        .media_changed =        pkt_media_changed,
+        .check_events =         pkt_check_events,
 };
 
 static char *pktcdvd_devnode(struct gendisk *gd, mode_t *mode)
@@ -2889,6 +2888,10 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
         if (ret)
                 goto out_new_dev;
 
+        /* inherit events of the host device */
+        disk->events = pd->bdev->bd_disk->events;
+        disk->async_events = pd->bdev->bd_disk->async_events;
+
         add_disk(disk);
 
         pkt_sysfs_dev_new(pd);
diff --git a/drivers/block/swim.c b/drivers/block/swim.c
index 75333d0a3327..24a482f2fbd6 100644
--- a/drivers/block/swim.c
+++ b/drivers/block/swim.c
@@ -741,11 +741,12 @@ static int floppy_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return 0;
 }
 
-static int floppy_check_change(struct gendisk *disk)
+static unsigned int floppy_check_events(struct gendisk *disk,
+                                        unsigned int clearing)
 {
         struct floppy_state *fs = disk->private_data;
 
-        return fs->ejected;
+        return fs->ejected ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 static int floppy_revalidate(struct gendisk *disk)
@@ -772,7 +773,7 @@ static const struct block_device_operations floppy_fops = {
         .release         = floppy_release,
         .ioctl           = floppy_ioctl,
         .getgeo          = floppy_getgeo,
-        .media_changed   = floppy_check_change,
+        .check_events    = floppy_check_events,
         .revalidate_disk = floppy_revalidate,
 };
 
@@ -857,6 +858,7 @@ static int __devinit swim_floppy_init(struct swim_priv *swd)
                 swd->unit[drive].disk->first_minor = drive;
                 sprintf(swd->unit[drive].disk->disk_name, "fd%d", drive);
                 swd->unit[drive].disk->fops = &floppy_fops;
+                swd->unit[drive].disk->events = DISK_EVENT_MEDIA_CHANGE;
                 swd->unit[drive].disk->private_data = &swd->unit[drive];
                 swd->unit[drive].disk->queue = swd->queue;
                 set_capacity(swd->unit[drive].disk, 2880);
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index bf3a5b859299..4c10f56facbf 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -250,7 +250,8 @@ static int floppy_ioctl(struct block_device *bdev, fmode_t mode,
                         unsigned int cmd, unsigned long param);
 static int floppy_open(struct block_device *bdev, fmode_t mode);
 static int floppy_release(struct gendisk *disk, fmode_t mode);
-static int floppy_check_change(struct gendisk *disk);
+static unsigned int floppy_check_events(struct gendisk *disk,
+                                        unsigned int clearing);
 static int floppy_revalidate(struct gendisk *disk);
 
 static bool swim3_end_request(int err, unsigned int nr_bytes)
@@ -975,10 +976,11 @@ static int floppy_release(struct gendisk *disk, fmode_t mode)
         return 0;
 }
 
-static int floppy_check_change(struct gendisk *disk)
+static unsigned int floppy_check_events(struct gendisk *disk,
+                                        unsigned int clearing)
 {
         struct floppy_state *fs = disk->private_data;
-        return fs->ejected;
+        return fs->ejected ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 static int floppy_revalidate(struct gendisk *disk)
@@ -1025,7 +1027,7 @@ static const struct block_device_operations floppy_fops = {
         .open           = floppy_unlocked_open,
         .release        = floppy_release,
         .ioctl          = floppy_ioctl,
-        .media_changed  = floppy_check_change,
+        .check_events   = floppy_check_events,
         .revalidate_disk= floppy_revalidate,
 };
 
@@ -1161,6 +1163,7 @@ static int __devinit swim3_attach(struct macio_dev *mdev, const struct of_device
         disk->major = FLOPPY_MAJOR;
         disk->first_minor = i;
         disk->fops = &floppy_fops;
+        disk->events = DISK_EVENT_MEDIA_CHANGE;
         disk->private_data = &floppy_states[i];
         disk->queue = swim3_queue;
         disk->flags |= GENHD_FL_REMOVABLE;
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 9ae3bb713286..68b9430c7cfe 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -1788,7 +1788,8 @@ static int ub_bd_revalidate(struct gendisk *disk)
  *
  * The return code is bool!
  */
-static int ub_bd_media_changed(struct gendisk *disk)
+static unsigned int ub_bd_check_events(struct gendisk *disk,
+                                       unsigned int clearing)
 {
         struct ub_lun *lun = disk->private_data;
 
@@ -1806,10 +1807,10 @@ static int ub_bd_media_changed(struct gendisk *disk)
          */
         if (ub_sync_tur(lun->udev, lun) != 0) {
                 lun->changed = 1;
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
         }
 
-        return lun->changed;
+        return lun->changed ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 static const struct block_device_operations ub_bd_fops = {
@@ -1817,7 +1818,7 @@ static const struct block_device_operations ub_bd_fops = {
         .open           = ub_bd_unlocked_open,
         .release        = ub_bd_release,
         .ioctl          = ub_bd_ioctl,
-        .media_changed  = ub_bd_media_changed,
+        .check_events   = ub_bd_check_events,
         .revalidate_disk = ub_bd_revalidate,
 };
 
@@ -2333,6 +2334,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum)
         disk->major = UB_MAJOR;
         disk->first_minor = lun->id * UB_PARTS_PER_LUN;
         disk->fops = &ub_bd_fops;
+        disk->events = DISK_EVENT_MEDIA_CHANGE;
         disk->private_data = lun;
         disk->driverfs_dev = &sc->intf->dev;
 
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index 8be57151f5d6..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
- * when mm_unplug_device is called via the unplug_io_fn.
+ * Otherwise the Ready page is only activated when it becomes full.
  *
  * 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;
@@ -779,20 +766,10 @@ static int mm_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return 0;
 }
 
-/*
- * Future support for removable devices
- */
-static int mm_check_change(struct gendisk *disk)
-{
-/*  struct cardinfo *dev = disk->private_data; */
-        return 0;
-}
-
 static const struct block_device_operations mm_fops = {
         .owner          = THIS_MODULE,
         .getgeo         = mm_getgeo,
         .revalidate_disk = mm_revalidate,
-        .media_changed  = mm_check_change,
 };
 
 static int __devinit mm_pci_probe(struct pci_dev *dev,
@@ -907,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/block/xsysace.c b/drivers/block/xsysace.c
index 2c590a796aa1..73354b081ed3 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -867,12 +867,12 @@ static void ace_request(struct request_queue * q)
         }
 }
 
-static int ace_media_changed(struct gendisk *gd)
+static unsigned int ace_check_events(struct gendisk *gd, unsigned int clearing)
 {
         struct ace_device *ace = gd->private_data;
-        dev_dbg(ace->dev, "ace_media_changed(): %i\n", ace->media_change);
+        dev_dbg(ace->dev, "ace_check_events(): %i\n", ace->media_change);
 
-        return ace->media_change;
+        return ace->media_change ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 static int ace_revalidate_disk(struct gendisk *gd)
@@ -953,7 +953,7 @@ static const struct block_device_operations ace_fops = {
         .owner = THIS_MODULE,
         .open = ace_open,
         .release = ace_release,
-        .media_changed = ace_media_changed,
+        .check_events = ace_check_events,
         .revalidate_disk = ace_revalidate_disk,
         .getgeo = ace_getgeo,
 };
@@ -1005,6 +1005,7 @@ static int __devinit ace_setup(struct ace_device *ace)
         ace->gd->major = ace_major;
         ace->gd->first_minor = ace->id * ACE_NUM_MINORS;
         ace->gd->fops = &ace_fops;
+        ace->gd->events = DISK_EVENT_MEDIA_CHANGE;
         ace->gd->queue = ace->queue;
         ace->gd->private_data = ace;
         snprintf(ace->gd->disk_name, 32, "xs%c", ace->id + 'a');
diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index 64a21461c408..b2b034fea34e 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -395,10 +395,12 @@ static int gdrom_drivestatus(struct cdrom_device_info *cd_info, int ignore)
         return CDS_NO_INFO;
 }
 
-static int gdrom_mediachanged(struct cdrom_device_info *cd_info, int ignore)
+static unsigned int gdrom_check_events(struct cdrom_device_info *cd_info,
+                                       unsigned int clearing, int ignore)
 {
         /* check the sense key */
-        return (__raw_readb(GDROM_ERROR_REG) & 0xF0) == 0x60;
+        return (__raw_readb(GDROM_ERROR_REG) & 0xF0) == 0x60 ?
+                DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 /* reset the G1 bus */
@@ -483,7 +485,7 @@ static struct cdrom_device_ops gdrom_ops = {
         .open                   = gdrom_open,
         .release                = gdrom_release,
         .drive_status           = gdrom_drivestatus,
-        .media_changed          = gdrom_mediachanged,
+        .check_events           = gdrom_check_events,
         .get_last_session       = gdrom_get_last_session,
         .reset                  = gdrom_hardreset,
         .audio_ioctl            = gdrom_audio_ioctl,
@@ -509,9 +511,10 @@ static int gdrom_bdops_release(struct gendisk *disk, fmode_t mode)
         return 0;
 }
 
-static int gdrom_bdops_mediachanged(struct gendisk *disk)
+static unsigned int gdrom_bdops_check_events(struct gendisk *disk,
+                                             unsigned int clearing)
 {
-        return cdrom_media_changed(gd.cd_info);
+        return cdrom_check_events(gd.cd_info, clearing);
 }
 
 static int gdrom_bdops_ioctl(struct block_device *bdev, fmode_t mode,
@@ -530,7 +533,7 @@ static const struct block_device_operations gdrom_bdops = {
         .owner                  = THIS_MODULE,
         .open                   = gdrom_bdops_open,
         .release                = gdrom_bdops_release,
-        .media_changed          = gdrom_bdops_mediachanged,
+        .check_events           = gdrom_bdops_check_events,
         .ioctl                  = gdrom_bdops_ioctl,
 };
 
@@ -800,6 +803,7 @@ static int __devinit probe_gdrom(struct platform_device *devptr)
                 goto probe_fail_cdrom_register;
         }
         gd.disk->fops = &gdrom_bdops;
+        gd.disk->events = DISK_EVENT_MEDIA_CHANGE;
         /* latch on to the interrupt */
         err = gdrom_set_interrupt_handlers();
         if (err)
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index be73a9b493a6..4e874c5fa605 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -186,10 +186,11 @@ static int viocd_blk_ioctl(struct block_device *bdev, fmode_t mode,
         return ret;
 }
 
-static int viocd_blk_media_changed(struct gendisk *disk)
+static unsigned int viocd_blk_check_events(struct gendisk *disk,
+                                           unsigned int clearing)
 {
         struct disk_info *di = disk->private_data;
-        return cdrom_media_changed(&di->viocd_info);
+        return cdrom_check_events(&di->viocd_info, clearing);
 }
 
 static const struct block_device_operations viocd_fops = {
@@ -197,7 +198,7 @@ static const struct block_device_operations viocd_fops = {
         .open =                 viocd_blk_open,
         .release =              viocd_blk_release,
         .ioctl =                viocd_blk_ioctl,
-        .media_changed =        viocd_blk_media_changed,
+        .check_events =         viocd_blk_check_events,
 };
 
 static int viocd_open(struct cdrom_device_info *cdi, int purpose)
@@ -320,7 +321,8 @@ static void do_viocd_request(struct request_queue *q)
         }
 }
 
-static int viocd_media_changed(struct cdrom_device_info *cdi, int disc_nr)
+static unsigned int viocd_check_events(struct cdrom_device_info *cdi,
+                                       unsigned int clearing, int disc_nr)
 {
         struct viocd_waitevent we;
         HvLpEvent_Rc hvrc;
@@ -340,7 +342,7 @@ static int viocd_media_changed(struct cdrom_device_info *cdi, int disc_nr)
         if (hvrc != 0) {
                 pr_warning("bad rc on HvCallEvent_signalLpEventFast %d\n",
                            (int)hvrc);
-                return -EIO;
+                return 0;
         }
 
         wait_for_completion(&we.com);
@@ -354,7 +356,7 @@ static int viocd_media_changed(struct cdrom_device_info *cdi, int disc_nr)
                 return 0;
         }
 
-        return we.changed;
+        return we.changed ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 static int viocd_lock_door(struct cdrom_device_info *cdi, int locking)
@@ -550,7 +552,7 @@ static int viocd_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
 static struct cdrom_device_ops viocd_dops = {
         .open = viocd_open,
         .release = viocd_release,
-        .media_changed = viocd_media_changed,
+        .check_events = viocd_check_events,
         .lock_door = viocd_lock_door,
         .generic_packet = viocd_packet,
         .audio_ioctl = viocd_audio_ioctl,
@@ -624,6 +626,7 @@ static int viocd_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         gendisk->queue = q;
         gendisk->fops = &viocd_fops;
         gendisk->flags = GENHD_FL_CD|GENHD_FL_REMOVABLE;
+        gendisk->events = DISK_EVENT_MEDIA_CHANGE;
         set_capacity(gendisk, 0);
         gendisk->private_data = d;
         d->viocd_disk = gendisk;
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,
-                        ELEVATOR_INSERT_FRONT, 0);
+        elv_add_request(drive->queue, &drive->sense_rq, ELEVATOR_INSERT_FRONT);
         return 0;
 }
 EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 0c73fe39a236..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
                  */
-
-                spin_lock_irqsave(q->queue_lock, flags);
-                blk_plug_device(q);
-                spin_unlock_irqrestore(q->queue_lock, flags);
-
+                blk_delay_queue(drive->queue, 1);
                 return 1;
         }
 }
@@ -1177,7 +1170,7 @@ static struct cdrom_device_ops ide_cdrom_dops = {
         .open                   = ide_cdrom_open_real,
         .release                = ide_cdrom_release_real,
         .drive_status           = ide_cdrom_drive_status,
-        .media_changed          = ide_cdrom_check_media_change_real,
+        .check_events           = ide_cdrom_check_events_real,
         .tray_move              = ide_cdrom_tray_move,
         .lock_door              = ide_cdrom_lock_door,
         .select_speed           = ide_cdrom_select_speed,
@@ -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);
 
@@ -1702,10 +1693,11 @@ static int idecd_ioctl(struct block_device *bdev, fmode_t mode,
 }
 
 
-static int idecd_media_changed(struct gendisk *disk)
+static unsigned int idecd_check_events(struct gendisk *disk,
+                                       unsigned int clearing)
 {
         struct cdrom_info *info = ide_drv_g(disk, cdrom_info);
-        return cdrom_media_changed(&info->devinfo);
+        return cdrom_check_events(&info->devinfo, clearing);
 }
 
 static int idecd_revalidate_disk(struct gendisk *disk)
@@ -1723,7 +1715,7 @@ static const struct block_device_operations idecd_ops = {
         .open                   = idecd_open,
         .release                = idecd_release,
         .ioctl                  = idecd_ioctl,
-        .media_changed          = idecd_media_changed,
+        .check_events           = idecd_check_events,
         .revalidate_disk        = idecd_revalidate_disk
 };
 
@@ -1790,6 +1782,7 @@ static int ide_cd_probe(ide_drive_t *drive)
         ide_cd_read_toc(drive, &sense);
         g->fops = &idecd_ops;
         g->flags |= GENHD_FL_REMOVABLE;
+        g->events = DISK_EVENT_MEDIA_CHANGE;
         add_disk(g);
         return 0;
 
diff --git a/drivers/ide/ide-cd.h b/drivers/ide/ide-cd.h
index 93a3cf1b0f3f..1efc936f5b66 100644
--- a/drivers/ide/ide-cd.h
+++ b/drivers/ide/ide-cd.h
@@ -111,7 +111,8 @@ int cdrom_check_status(ide_drive_t *, struct request_sense *);
 int ide_cdrom_open_real(struct cdrom_device_info *, int);
 void ide_cdrom_release_real(struct cdrom_device_info *);
 int ide_cdrom_drive_status(struct cdrom_device_info *, int);
-int ide_cdrom_check_media_change_real(struct cdrom_device_info *, int);
+unsigned int ide_cdrom_check_events_real(struct cdrom_device_info *,
+                                         unsigned int clearing, int slot_nr);
 int ide_cdrom_tray_move(struct cdrom_device_info *, int);
 int ide_cdrom_lock_door(struct cdrom_device_info *, int);
 int ide_cdrom_select_speed(struct cdrom_device_info *, int);
diff --git a/drivers/ide/ide-cd_ioctl.c b/drivers/ide/ide-cd_ioctl.c
index 766b3deeb23c..2a6bc50e8a41 100644
--- a/drivers/ide/ide-cd_ioctl.c
+++ b/drivers/ide/ide-cd_ioctl.c
@@ -79,8 +79,8 @@ int ide_cdrom_drive_status(struct cdrom_device_info *cdi, int slot_nr)
         return CDS_DRIVE_NOT_READY;
 }
 
-int ide_cdrom_check_media_change_real(struct cdrom_device_info *cdi,
-                                       int slot_nr)
+unsigned int ide_cdrom_check_events_real(struct cdrom_device_info *cdi,
+                                         unsigned int clearing, int slot_nr)
 {
         ide_drive_t *drive = cdi->handle;
         int retval;
@@ -89,9 +89,9 @@ int ide_cdrom_check_media_change_real(struct cdrom_device_info *cdi,
                 (void) cdrom_check_status(drive, NULL);
                 retval = (drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED) ? 1 : 0;
                 drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
-                return retval;
+                return retval ? DISK_EVENT_MEDIA_CHANGE : 0;
         } else {
-                return -EINVAL;
+                return 0;
         }
 }
 
diff --git a/drivers/ide/ide-gd.c b/drivers/ide/ide-gd.c
index 35c4b43585e3..c4ffd4888939 100644
--- a/drivers/ide/ide-gd.c
+++ b/drivers/ide/ide-gd.c
@@ -285,11 +285,12 @@ static int ide_gd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return 0;
 }
 
-static int ide_gd_media_changed(struct gendisk *disk)
+static unsigned int ide_gd_check_events(struct gendisk *disk,
+                                        unsigned int clearing)
 {
         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
         ide_drive_t *drive = idkp->drive;
-        int ret;
+        bool ret;
 
         /* do not scan partitions twice if this is a removable device */
         if (drive->dev_flags & IDE_DFLAG_ATTACH) {
@@ -297,10 +298,10 @@ static int ide_gd_media_changed(struct gendisk *disk)
                 return 0;
         }
 
-        ret = !!(drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED);
+        ret = drive->dev_flags & IDE_DFLAG_MEDIA_CHANGED;
         drive->dev_flags &= ~IDE_DFLAG_MEDIA_CHANGED;
 
-        return ret;
+        return ret ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 static void ide_gd_unlock_native_capacity(struct gendisk *disk)
@@ -318,7 +319,7 @@ static int ide_gd_revalidate_disk(struct gendisk *disk)
         struct ide_disk_obj *idkp = ide_drv_g(disk, ide_disk_obj);
         ide_drive_t *drive = idkp->drive;
 
-        if (ide_gd_media_changed(disk))
+        if (ide_gd_check_events(disk, 0))
                 drive->disk_ops->get_capacity(drive);
 
         set_capacity(disk, ide_gd_capacity(drive));
@@ -340,7 +341,7 @@ static const struct block_device_operations ide_gd_ops = {
         .release                = ide_gd_release,
         .ioctl                  = ide_gd_ioctl,
         .getgeo                 = ide_gd_getgeo,
-        .media_changed          = ide_gd_media_changed,
+        .check_events           = ide_gd_check_events,
         .unlock_native_capacity = ide_gd_unlock_native_capacity,
         .revalidate_disk        = ide_gd_revalidate_disk
 };
@@ -412,6 +413,7 @@ static int ide_gd_probe(ide_drive_t *drive)
         if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
                 g->flags = GENHD_FL_REMOVABLE;
         g->fops = &ide_gd_ops;
+        g->events = DISK_EVENT_MEDIA_CHANGE;
         add_disk(g);
         return 0;
 
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 a2ce0b2da281..5c9362792f1d 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);
-                        schedule();
+                        io_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) {
-                kcryptd_unplug(cc);
+        if (!clone)
                 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 {
-                if (job->num_dests > 1)
-                        io_req.bi_rw |= REQ_UNPLUG;
+        else
                 r = dm_io(&io_req, job->num_dests, job->dests, NULL);
-                if (!(io_req.bi_rw & REQ_UNPLUG))
-                        prepare_unplug(job->kc, WRITE, job->dests[0].bdev);
-        }
 
         return r;
 }
@@ -466,6 +428,7 @@ static void do_work(struct work_struct *work)
 {
         struct dm_kcopyd_client *kc = container_of(work,
                                         struct dm_kcopyd_client, kcopyd_work);
+        struct blk_plug plug;
 
         /*
          * The order that these are called is *very* important.
@@ -473,18 +436,12 @@ static void do_work(struct work_struct *work)
          * Pages jobs when successful will jump onto the io jobs
          * list.  io jobs call wake when they complete and it all
          * starts again.
-         *
-         * Note that io_jobs add block devices to the unplug array,
-         * this array is cleared with "unplug" calls. It is thus
-         * forbidden to run complete_jobs after io_jobs and before
-         * unplug because the block device could be destroyed in
-         * job completion callback.
          */
+        blk_start_plug(&plug);
         process_jobs(&kc->complete_jobs, kc, run_complete_job);
         process_jobs(&kc->pages_jobs, kc, run_pages_job);
         process_jobs(&kc->io_jobs, kc, run_io_job);
-        unplug(kc, READ);
-        unplug(kc, WRITE);
+        blk_finish_plug(&plug);
 }
 
 /*
@@ -665,8 +622,6 @@ int dm_kcopyd_client_create(unsigned int nr_pages,
         INIT_LIST_HEAD(&kc->io_jobs);
         INIT_LIST_HEAD(&kc->pages_jobs);
 
-        memset(kc->unplug, 0, sizeof(kc->unplug));
-
         kc->job_pool = mempool_create_slab_pool(MIN_JOBS, _job_cache);
         if (!kc->job_pool)
                 goto bad_slab;
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..416d4e258df6 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -55,6 +55,7 @@ struct dm_table {
         struct dm_target *targets;
 
         unsigned discards_supported:1;
+        unsigned integrity_supported:1;
 
         /*
          * Indicates the rw permissions for the new logical
@@ -859,7 +860,7 @@ int dm_table_alloc_md_mempools(struct dm_table *t)
                 return -EINVAL;
         }
 
-        t->mempools = dm_alloc_md_mempools(type);
+        t->mempools = dm_alloc_md_mempools(type, t->integrity_supported);
         if (!t->mempools)
                 return -ENOMEM;
 
@@ -935,8 +936,10 @@ static int dm_table_prealloc_integrity(struct dm_table *t, struct mapped_device
         struct dm_dev_internal *dd;
 
         list_for_each_entry(dd, devices, list)
-                if (bdev_get_integrity(dd->dm_dev.bdev))
+                if (bdev_get_integrity(dd->dm_dev.bdev)) {
+                        t->integrity_supported = 1;
                         return blk_integrity_register(dm_disk(md), NULL);
+                }
 
         return 0;
 }
@@ -1275,29 +1278,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 +1325,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..0cf68b478878 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -477,7 +477,8 @@ static void start_io_acct(struct dm_io *io)
         cpu = part_stat_lock();
         part_round_stats(cpu, &dm_disk(md)->part0);
         part_stat_unlock();
-        dm_disk(md)->part0.in_flight[rw] = atomic_inc_return(&md->pending[rw]);
+        atomic_set(&dm_disk(md)->part0.in_flight[rw],
+                atomic_inc_return(&md->pending[rw]));
 }
 
 static void end_io_acct(struct dm_io *io)
@@ -497,8 +498,8 @@ static void end_io_acct(struct dm_io *io)
          * After this is decremented the bio must not be touched if it is
          * a flush.
          */
-        dm_disk(md)->part0.in_flight[rw] = pending =
-                atomic_dec_return(&md->pending[rw]);
+        pending = atomic_dec_return(&md->pending[rw]);
+        atomic_set(&dm_disk(md)->part0.in_flight[rw], pending);
         pending += atomic_read(&md->pending[rw^0x1]);
 
         /* nudge anyone waiting on suspend queue */
@@ -807,8 +808,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 +1612,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 +1626,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 +1646,8 @@ requeued:
         BUG_ON(!irqs_disabled());
         spin_lock(q->queue_lock);
 
-plug_and_out:
-        if (!elv_queue_empty(q))
-                /* Some requests still remain, retry later */
-                blk_plug_device(q);
-
+delay_and_out:
+        blk_delay_queue(q, HZ / 10);
 out:
         dm_table_put(map);
 
@@ -1680,20 +1676,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 +1799,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 +2244,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 +2518,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);
@@ -2643,9 +2621,10 @@ int dm_noflush_suspending(struct dm_target *ti)
 }
 EXPORT_SYMBOL_GPL(dm_noflush_suspending);
 
-struct dm_md_mempools *dm_alloc_md_mempools(unsigned type)
+struct dm_md_mempools *dm_alloc_md_mempools(unsigned type, unsigned integrity)
 {
         struct dm_md_mempools *pools = kmalloc(sizeof(*pools), GFP_KERNEL);
+        unsigned int pool_size = (type == DM_TYPE_BIO_BASED) ? 16 : MIN_IOS;
 
         if (!pools)
                 return NULL;
@@ -2662,13 +2641,18 @@ struct dm_md_mempools *dm_alloc_md_mempools(unsigned type)
         if (!pools->tio_pool)
                 goto free_io_pool_and_out;
 
-        pools->bs = (type == DM_TYPE_BIO_BASED) ?
-                    bioset_create(16, 0) : bioset_create(MIN_IOS, 0);
+        pools->bs = bioset_create(pool_size, 0);
         if (!pools->bs)
                 goto free_tio_pool_and_out;
 
+        if (integrity && bioset_integrity_create(pools->bs, pool_size))
+                goto free_bioset_and_out;
+
         return pools;
 
+free_bioset_and_out:
+        bioset_free(pools->bs);
+
 free_tio_pool_and_out:
         mempool_destroy(pools->tio_pool);
 
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 0c2dd5f4af76..1aaf16746da8 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -149,7 +149,7 @@ void dm_kcopyd_exit(void);
 /*
  * Mempool operations
  */
-struct dm_md_mempools *dm_alloc_md_mempools(unsigned type);
+struct dm_md_mempools *dm_alloc_md_mempools(unsigned type, unsigned integrity);
 void dm_free_md_mempools(struct dm_md_mempools *pools);
 
 #endif
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 0ed7f6bc2a7f..abfb59a61ede 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,11 +208,9 @@ 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);
-        return 0;
+        return md_integrity_register(mddev);
 }
 
 static void free_conf(struct rcu_head *head)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index d5ad7723b172..06ecea751a39 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,
-                   bio);
+        submit_bio(REQ_WRITE | REQ_SYNC | REQ_FLUSH | REQ_FUA, bio);
 }
 
 void md_super_wait(mddev_t *mddev)
@@ -809,7 +808,7 @@ int sync_page_io(mdk_rdev_t *rdev, sector_t sector, int size,
         struct completion event;
         int ret;
 
-        rw |= REQ_SYNC | REQ_UNPLUG;
+        rw |= REQ_SYNC;
 
         bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
                 rdev->meta_bdev : rdev->bdev;
@@ -1804,8 +1803,12 @@ int md_integrity_register(mddev_t *mddev)
                         mdname(mddev));
                 return -EINVAL;
         }
-        printk(KERN_NOTICE "md: data integrity on %s enabled\n",
-                mdname(mddev));
+        printk(KERN_NOTICE "md: data integrity enabled on %s\n", mdname(mddev));
+        if (bioset_integrity_create(mddev->bio_set, BIO_POOL_SIZE)) {
+                printk(KERN_ERR "md: failed to create integrity pool for %s\n",
+                       mdname(mddev));
+                return -EINVAL;
+        }
         return 0;
 }
 EXPORT_SYMBOL(md_integrity_register);
@@ -4817,7 +4820,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 +6694,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 +6876,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 +6951,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 +6969,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..c35890990985 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;
@@ -345,7 +315,7 @@ static int multipath_remove_disk(mddev_t *mddev, int number)
                         p->rdev = rdev;
                         goto abort;
                 }
-                md_integrity_register(mddev);
+                err = md_integrity_register(mddev);
         }
 abort:
 
@@ -517,10 +487,12 @@ 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);
+
+        if (md_integrity_register(mddev))
+                goto out_free_conf;
+
         return 0;
 
 out_free_conf:
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index c0ac457f1218..e86bf3682e1e 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;
 
@@ -395,8 +379,7 @@ static int raid0_run(mddev_t *mddev)
 
         blk_queue_merge_bvec(mddev->queue, raid0_mergeable_bvec);
         dump_zones(mddev);
-        md_integrity_register(mddev);
-        return 0;
+        return md_integrity_register(mddev);
 }
 
 static int raid0_stop(mddev_t *mddev)
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 06cd712807d0..c2a21ae56d97 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);
-        if (!r1_bio && pi->mddev)
-                unplug_slaves(pi->mddev);
-
-        return r1_bio;
+        return kzalloc(size, gfp_flags);
 }
 
 static void r1bio_pool_free(void *r1_bio, void *data)
@@ -91,10 +84,8 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
         int i, j;
 
         r1_bio = r1bio_pool_alloc(gfp_flags, pi);
-        if (!r1_bio) {
-                unplug_slaves(pi->mddev);
+        if (!r1_bio)
                 return NULL;
-        }
 
         /*
          * Allocate bios : 1 for reading, n-1 for writing
@@ -520,37 +511,6 @@ static int read_balance(conf_t *conf, r1bio_t *r1_bio)
         return new_disk;
 }
 
-static void unplug_slaves(mddev_t *mddev)
-{
-        conf_t *conf = mddev->private;
-        int i;
-
-        rcu_read_lock();
-        for (i=0; i<mddev->raid_disks; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
-
-                        atomic_inc(&rdev->nr_pending);
-                        rcu_read_unlock();
-
-                        blk_unplug(r_queue);
-
-                        rdev_dec_pending(rdev, mddev);
-                        rcu_read_lock();
-                }
-        }
-        rcu_read_unlock();
-}
-
-static void raid1_unplug(struct request_queue *q)
-{
-        mddev_t *mddev = q->queuedata;
-
-        unplug_slaves(mddev);
-        md_wakeup_thread(mddev->thread);
-}
-
 static int raid1_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
@@ -580,23 +540,16 @@ static int raid1_congested(void *data, int bits)
 }
 
 
-static int flush_pending_writes(conf_t *conf)
+static void flush_pending_writes(conf_t *conf)
 {
         /* Any writes that have been queued but are awaiting
          * bitmap updates get flushed here.
-         * We return 1 if any requests were actually submitted.
          */
-        int rv = 0;
-
         spin_lock_irq(&conf->device_lock);
 
         if (conf->pending_bio_list.head) {
                 struct bio *bio;
                 bio = bio_list_get(&conf->pending_bio_list);
-                /* Only take the spinlock to quiet a warning */
-                spin_lock(conf->mddev->queue->queue_lock);
-                blk_remove_plug(conf->mddev->queue);
-                spin_unlock(conf->mddev->queue->queue_lock);
                 spin_unlock_irq(&conf->device_lock);
                 /* flush any pending bitmap writes to
                  * disk before proceeding w/ I/O */
@@ -608,10 +561,14 @@ static int flush_pending_writes(conf_t *conf)
                         generic_make_request(bio);
                         bio = next;
                 }
-                rv = 1;
         } else
                 spin_unlock_irq(&conf->device_lock);
-        return rv;
+}
+
+static void md_kick_device(mddev_t *mddev)
+{
+        blk_flush_plug(current);
+        md_wakeup_thread(mddev->thread);
 }
 
 /* Barriers....
@@ -643,8 +600,7 @@ static void raise_barrier(conf_t *conf)
 
         /* Wait until no block IO is waiting */
         wait_event_lock_irq(conf->wait_barrier, !conf->nr_waiting,
-                            conf->resync_lock,
-                            raid1_unplug(conf->mddev->queue));
+                            conf->resync_lock, md_kick_device(conf->mddev));
 
         /* block any new IO from starting */
         conf->barrier++;
@@ -652,8 +608,7 @@ static void raise_barrier(conf_t *conf)
         /* Now wait for all pending IO to complete */
         wait_event_lock_irq(conf->wait_barrier,
                             !conf->nr_pending && conf->barrier < RESYNC_DEPTH,
-                            conf->resync_lock,
-                            raid1_unplug(conf->mddev->queue));
+                            conf->resync_lock, md_kick_device(conf->mddev));
 
         spin_unlock_irq(&conf->resync_lock);
 }
@@ -675,7 +630,7 @@ static void wait_barrier(conf_t *conf)
                 conf->nr_waiting++;
                 wait_event_lock_irq(conf->wait_barrier, !conf->barrier,
                                     conf->resync_lock,
-                                    raid1_unplug(conf->mddev->queue));
+                                    md_kick_device(conf->mddev));
                 conf->nr_waiting--;
         }
         conf->nr_pending++;
@@ -712,7 +667,7 @@ static void freeze_array(conf_t *conf)
                             conf->nr_pending == conf->nr_queued+1,
                             conf->resync_lock,
                             ({ flush_pending_writes(conf);
-                               raid1_unplug(conf->mddev->queue); }));
+                               md_kick_device(conf->mddev); }));
         spin_unlock_irq(&conf->resync_lock);
 }
 static void unfreeze_array(conf_t *conf)
@@ -962,7 +917,6 @@ static int make_request(mddev_t *mddev, struct bio * bio)
                 atomic_inc(&r1_bio->remaining);
                 spin_lock_irqsave(&conf->device_lock, flags);
                 bio_list_add(&conf->pending_bio_list, mbio);
-                blk_plug_device_unlocked(mddev->queue);
                 spin_unlock_irqrestore(&conf->device_lock, flags);
         }
         r1_bio_write_done(r1_bio, bio->bi_vcnt, behind_pages, behind_pages != NULL);
@@ -971,7 +925,7 @@ static int make_request(mddev_t *mddev, struct bio * bio)
         /* In case raid1d snuck in to freeze_array */
         wake_up(&conf->wait_barrier);
 
-        if (do_sync)
+        if (do_sync || !bitmap)
                 md_wakeup_thread(mddev->thread);
 
         return 0;
@@ -1178,7 +1132,7 @@ static int raid1_remove_disk(mddev_t *mddev, int number)
                         p->rdev = rdev;
                         goto abort;
                 }
-                md_integrity_register(mddev);
+                err = md_integrity_register(mddev);
         }
 abort:
 
@@ -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,11 +2015,9 @@ 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);
-        return 0;
+        return md_integrity_register(mddev);
 }
 
 static int stop(mddev_t *mddev)
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 747d061d8e05..f7b62370b374 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);
-        if (!r10_bio && conf->mddev)
-                unplug_slaves(conf->mddev);
-
-        return r10_bio;
+        return kzalloc(size, gfp_flags);
 }
 
 static void r10bio_pool_free(void *r10_bio, void *data)
@@ -106,10 +99,8 @@ static void * r10buf_pool_alloc(gfp_t gfp_flags, void *data)
         int nalloc;
 
         r10_bio = r10bio_pool_alloc(gfp_flags, conf);
-        if (!r10_bio) {
-                unplug_slaves(conf->mddev);
+        if (!r10_bio)
                 return NULL;
-        }
 
         if (test_bit(MD_RECOVERY_SYNC, &conf->mddev->recovery))
                 nalloc = conf->copies; /* resync */
@@ -597,37 +588,6 @@ rb_out:
         return disk;
 }
 
-static void unplug_slaves(mddev_t *mddev)
-{
-        conf_t *conf = mddev->private;
-        int i;
-
-        rcu_read_lock();
-        for (i=0; i < conf->raid_disks; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->mirrors[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
-
-                        atomic_inc(&rdev->nr_pending);
-                        rcu_read_unlock();
-
-                        blk_unplug(r_queue);
-
-                        rdev_dec_pending(rdev, mddev);
-                        rcu_read_lock();
-                }
-        }
-        rcu_read_unlock();
-}
-
-static void raid10_unplug(struct request_queue *q)
-{
-        mddev_t *mddev = q->queuedata;
-
-        unplug_slaves(q->queuedata);
-        md_wakeup_thread(mddev->thread);
-}
-
 static int raid10_congested(void *data, int bits)
 {
         mddev_t *mddev = data;
@@ -649,23 +609,16 @@ static int raid10_congested(void *data, int bits)
         return ret;
 }
 
-static int flush_pending_writes(conf_t *conf)
+static void flush_pending_writes(conf_t *conf)
 {
         /* Any writes that have been queued but are awaiting
          * bitmap updates get flushed here.
-         * We return 1 if any requests were actually submitted.
          */
-        int rv = 0;
-
         spin_lock_irq(&conf->device_lock);
 
         if (conf->pending_bio_list.head) {
                 struct bio *bio;
                 bio = bio_list_get(&conf->pending_bio_list);
-                /* Spinlock only taken to quiet a warning */
-                spin_lock(conf->mddev->queue->queue_lock);
-                blk_remove_plug(conf->mddev->queue);
-                spin_unlock(conf->mddev->queue->queue_lock);
                 spin_unlock_irq(&conf->device_lock);
                 /* flush any pending bitmap writes to disk
                  * before proceeding w/ I/O */
@@ -677,11 +630,16 @@ static int flush_pending_writes(conf_t *conf)
                         generic_make_request(bio);
                         bio = next;
                 }
-                rv = 1;
         } else
                 spin_unlock_irq(&conf->device_lock);
-        return rv;
 }
+
+static void md_kick_device(mddev_t *mddev)
+{
+        blk_flush_plug(current);
+        md_wakeup_thread(mddev->thread);
+}
+
 /* Barriers....
  * Sometimes we need to suspend IO while we do something else,
  * either some resync/recovery, or reconfigure the array.
@@ -711,8 +669,7 @@ static void raise_barrier(conf_t *conf, int force)
 
         /* Wait until no block IO is waiting (unless 'force') */
         wait_event_lock_irq(conf->wait_barrier, force || !conf->nr_waiting,
-                            conf->resync_lock,
-                            raid10_unplug(conf->mddev->queue));
+                            conf->resync_lock, md_kick_device(conf->mddev));
 
         /* block any new IO from starting */
         conf->barrier++;
@@ -720,8 +677,7 @@ static void raise_barrier(conf_t *conf, int force)
         /* No wait for all pending IO to complete */
         wait_event_lock_irq(conf->wait_barrier,
                             !conf->nr_pending && conf->barrier < RESYNC_DEPTH,
-                            conf->resync_lock,
-                            raid10_unplug(conf->mddev->queue));
+                            conf->resync_lock, md_kick_device(conf->mddev));
 
         spin_unlock_irq(&conf->resync_lock);
 }
@@ -742,7 +698,7 @@ static void wait_barrier(conf_t *conf)
                 conf->nr_waiting++;
                 wait_event_lock_irq(conf->wait_barrier, !conf->barrier,
                                     conf->resync_lock,
-                                    raid10_unplug(conf->mddev->queue));
+                                    md_kick_device(conf->mddev));
                 conf->nr_waiting--;
         }
         conf->nr_pending++;
@@ -779,7 +735,7 @@ static void freeze_array(conf_t *conf)
                             conf->nr_pending == conf->nr_queued+1,
                             conf->resync_lock,
                             ({ flush_pending_writes(conf);
-                               raid10_unplug(conf->mddev->queue); }));
+                               md_kick_device(conf->mddev); }));
         spin_unlock_irq(&conf->resync_lock);
 }
 
@@ -974,7 +930,6 @@ static int make_request(mddev_t *mddev, struct bio * bio)
                 atomic_inc(&r10_bio->remaining);
                 spin_lock_irqsave(&conf->device_lock, flags);
                 bio_list_add(&conf->pending_bio_list, mbio);
-                blk_plug_device_unlocked(mddev->queue);
                 spin_unlock_irqrestore(&conf->device_lock, flags);
         }
 
@@ -991,7 +946,7 @@ static int make_request(mddev_t *mddev, struct bio * bio)
         /* In case raid10d snuck in to freeze_array */
         wake_up(&conf->wait_barrier);
 
-        if (do_sync)
+        if (do_sync || !mddev->bitmap)
                 md_wakeup_thread(mddev->thread);
 
         return 0;
@@ -1233,7 +1188,7 @@ static int raid10_remove_disk(mddev_t *mddev, int number)
                         p->rdev = rdev;
                         goto abort;
                 }
-                md_integrity_register(mddev);
+                err = md_integrity_register(mddev);
         }
 abort:
 
@@ -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;
 
@@ -2395,7 +2343,10 @@ static int run(mddev_t *mddev)
 
         if (conf->near_copies < conf->raid_disks)
                 blk_queue_merge_bvec(mddev->queue, raid10_mergeable_bvec);
-        md_integrity_register(mddev);
+
+        if (md_integrity_register(mddev))
+                goto out_free_conf;
+
         return 0;
 
 out_free_conf:
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;
-        int i;
-        int devs = max(conf->raid_disks, conf->previous_raid_disks);
-
-        rcu_read_lock();
-        for (i = 0; i < devs; i++) {
-                mdk_rdev_t *rdev = rcu_dereference(conf->disks[i].rdev);
-                if (rdev && !test_bit(Faulty, &rdev->flags) && atomic_read(&rdev->nr_pending)) {
-                        struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
-
-                        atomic_inc(&rdev->nr_pending);
-                        rcu_read_unlock();
-
-                        blk_unplug(r_queue);
-
-                        rdev_dec_pending(rdev, mddev);
-                        rcu_read_lock();
-                }
-        }
-        rcu_read_unlock();
-}
-
-void md_raid5_unplug_device(raid5_conf_t *conf)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&conf->device_lock, flags);
-
-        if (plugger_remove_plug(&conf->plug)) {
-                conf->seq_flush++;
-                raid5_activate_delayed(conf);
-        }
+        blk_flush_plug(current);
+        raid5_activate_delayed(conf);
         md_wakeup_thread(conf->mddev->thread);
-
-        spin_unlock_irqrestore(&conf->device_lock, flags);
-
-        unplug_slaves(conf->mddev);
 }
-EXPORT_SYMBOL_GPL(md_raid5_unplug_device);
+EXPORT_SYMBOL_GPL(md_raid5_kick_device);
 
 static void raid5_unplug(struct plug_handle *plug)
 {
         raid5_conf_t *conf = container_of(plug, raid5_conf_t, plug);
-        md_raid5_unplug_device(conf);
-}
 
-static void raid5_unplug_queue(struct request_queue *q)
-{
-        mddev_t *mddev = q->queuedata;
-        md_raid5_unplug_device(mddev->private);
+        md_raid5_kick_device(conf);
 }
 
 int md_raid5_congested(mddev_t *mddev, int bits)
@@ -4100,7 +4057,7 @@ static int make_request(mddev_t *mddev, struct bio * bi)
                                  * add failed due to overlap.  Flush everything
                                  * and wait a while
                                  */
-                                md_raid5_unplug_device(conf);
+                                md_raid5_kick_device(conf);
                                 release_stripe(sh);
                                 schedule();
                                 goto retry;
@@ -4365,7 +4322,6 @@ static inline sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *ski
 
         if (sector_nr >= max_sector) {
                 /* just being told to finish up .. nothing much to do */
-                unplug_slaves(mddev);
 
                 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
                         end_reshape(conf);
@@ -4569,7 +4525,6 @@ static void raid5d(mddev_t *mddev)
         spin_unlock_irq(&conf->device_lock);
 
         async_tx_issue_pending_all();
-        unplug_slaves(mddev);
 
         pr_debug("--- raid5d inactive\n");
 }
@@ -5204,7 +5159,7 @@ static int run(mddev_t *mddev)
 
                 mddev->queue->backing_dev_info.congested_data = mddev;
                 mddev->queue->backing_dev_info.congested_fn = raid5_congested;
-                mddev->queue->unplug_fn = raid5_unplug_queue;
+                mddev->queue->queue_lock = &conf->device_lock;
 
                 chunk_size = mddev->chunk_sectors << 9;
                 blk_queue_io_min(mddev->queue, chunk_size);
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 ae7cad185898..47ec5bc0ed21 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -695,20 +695,22 @@ static int i2o_block_ioctl(struct block_device *bdev, fmode_t mode,
 };
 
 /**
- *      i2o_block_media_changed - Have we seen a media change?
+ *      i2o_block_check_events - Have we seen a media change?
  *      @disk: gendisk which should be verified
+ *      @clearing: events being cleared
  *
  *      Verifies if the media has changed.
  *
  *      Returns 1 if the media was changed or 0 otherwise.
  */
-static int i2o_block_media_changed(struct gendisk *disk)
+static unsigned int i2o_block_check_events(struct gendisk *disk,
+                                           unsigned int clearing)
 {
         struct i2o_block_device *p = disk->private_data;
 
         if (p->media_change_flag) {
                 p->media_change_flag = 0;
-                return 1;
+                return DISK_EVENT_MEDIA_CHANGE;
         }
         return 0;
 }
@@ -895,11 +897,7 @@ static void i2o_block_request_fn(struct request_queue *q)
 {
         struct request *req;
 
-        while (!blk_queue_plugged(q)) {
-                req = blk_peek_request(q);
-                if (!req)
-                        break;
-
+        while ((req = blk_peek_request(q)) != NULL) {
                 if (req->cmd_type == REQ_TYPE_FS) {
                         struct i2o_block_delayed_request *dreq;
                         struct i2o_block_request *ireq = req->special;
@@ -950,7 +948,7 @@ static const struct block_device_operations i2o_block_fops = {
         .ioctl = i2o_block_ioctl,
         .compat_ioctl = i2o_block_ioctl,
         .getgeo = i2o_block_getgeo,
-        .media_changed = i2o_block_media_changed
+        .check_events = i2o_block_check_events,
 };
 
 /**
@@ -1002,6 +1000,7 @@ static struct i2o_block_device *i2o_block_device_alloc(void)
         gd->major = I2O_MAJOR;
         gd->queue = queue;
         gd->fops = &i2o_block_fops;
+        gd->events = DISK_EVENT_MEDIA_CHANGE;
         gd->private_data = dev;
 
         dev->gd = gd;
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 55d2d0f4eabc..83cea9a55e2f 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -48,14 +48,14 @@
 static DEFINE_MUTEX(tape_block_mutex);
 static int tapeblock_open(struct block_device *, fmode_t);
 static int tapeblock_release(struct gendisk *, fmode_t);
-static int tapeblock_medium_changed(struct gendisk *);
+static unsigned int tapeblock_check_events(struct gendisk *, unsigned int);
 static int tapeblock_revalidate_disk(struct gendisk *);
 
 static const struct block_device_operations tapeblock_fops = {
         .owner           = THIS_MODULE,
         .open            = tapeblock_open,
         .release         = tapeblock_release,
-        .media_changed   = tapeblock_medium_changed,
+        .check_events    = tapeblock_check_events,
         .revalidate_disk = tapeblock_revalidate_disk,
 };
 
@@ -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
         ) {
@@ -237,6 +236,7 @@ tapeblock_setup_device(struct tape_device * device)
         disk->major = tapeblock_major;
         disk->first_minor = device->first_minor;
         disk->fops = &tapeblock_fops;
+        disk->events = DISK_EVENT_MEDIA_CHANGE;
         disk->private_data = tape_get_device(device);
         disk->queue = blkdat->request_queue;
         set_capacity(disk, 0);
@@ -340,8 +340,8 @@ tapeblock_revalidate_disk(struct gendisk *disk)
         return 0;
 }
 
-static int
-tapeblock_medium_changed(struct gendisk *disk)
+static unsigned int
+tapeblock_check_events(struct gendisk *disk, unsigned int clearing)
 {
         struct tape_device *device;
 
@@ -349,7 +349,7 @@ tapeblock_medium_changed(struct gendisk *disk)
         DBF_LH(6, "tapeblock_medium_changed(%p) = %d\n",
                 device, device->blk_data.medium_changed);
 
-        return device->blk_data.medium_changed;
+        return device->blk_data.medium_changed ? DISK_EVENT_MEDIA_CHANGE : 0;
 }
 
 /*
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 2d63c8ad1442..6d5c7ff43f5b 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);
@@ -1226,11 +1226,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
-                 * command will automatically do that.
+                 * queue must be restarted, so we schedule a callback to happen
+                 * shortly.
                  */
                 if (sdev->device_busy == 0)
-                        blk_plug_device(q);
+                        blk_delay_queue(q, SCSI_QUEUE_DELAY);
                 break;
         default:
                 req->cmd_flags |= REQ_DONTPREP;
@@ -1269,7 +1269,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;
                 }
         }
@@ -1499,7 +1499,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
@@ -1578,15 +1578,8 @@ static void scsi_request_fn(struct request_queue *q)
                  */
                 rtn = scsi_dispatch_cmd(cmd);
                 spin_lock_irq(q->queue_lock);
-                if(rtn) {
-                        /* we're refusing the command; because of
-                         * the way locks get dropped, we need to 
-                         * check here if plugging is required */
-                        if(sdev->device_busy == 0)
-                                blk_plug_device(q);
-
-                        break;
-                }
+                if (rtn)
+                        goto out_delay;
         }
 
         goto out;
@@ -1605,9 +1598,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)
-                blk_plug_device(q);
- out:
+out_delay:
+        if (sdev->device_busy == 0)
+                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)) {
-                req = blk_fetch_request(q);
-                if (!req)
-                        break;
-
+        while ((req = blk_fetch_request(q)) != NULL) {
                 spin_unlock_irq(q->queue_lock);
 
                 handler = to_sas_internal(shost->transportt)->f->smp_handler;
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 6e02f1b0c46f..af789937be4e 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -124,7 +124,8 @@ static void blkvsc_shutdown(struct device *device);
 
 static int blkvsc_open(struct block_device *bdev,  fmode_t mode);
 static int blkvsc_release(struct gendisk *disk, fmode_t mode);
-static int blkvsc_media_changed(struct gendisk *gd);
+static unsigned int blkvsc_check_events(struct gendisk *gd,
+                                        unsigned int clearing);
 static int blkvsc_revalidate_disk(struct gendisk *gd);
 static int blkvsc_getgeo(struct block_device *bd, struct hd_geometry *hg);
 static int blkvsc_ioctl(struct block_device *bd, fmode_t mode,
@@ -155,7 +156,7 @@ static const struct block_device_operations block_ops = {
         .owner = THIS_MODULE,
         .open = blkvsc_open,
         .release = blkvsc_release,
-        .media_changed = blkvsc_media_changed,
+        .check_events = blkvsc_check_events,
         .revalidate_disk = blkvsc_revalidate_disk,
         .getgeo = blkvsc_getgeo,
         .ioctl  = blkvsc_ioctl,
@@ -357,6 +358,7 @@ static int blkvsc_probe(struct device *device)
         else
                 blkdev->gd->first_minor = 0;
         blkdev->gd->fops = &block_ops;
+        blkdev->gd->events = DISK_EVENT_MEDIA_CHANGE;
         blkdev->gd->private_data = blkdev;
         blkdev->gd->driverfs_dev = &(blkdev->device_ctx->device);
         sprintf(blkdev->gd->disk_name, "hd%c", 'a' + devnum);
@@ -1337,10 +1339,11 @@ static int blkvsc_release(struct gendisk *disk, fmode_t mode)
         return 0;
 }
 
-static int blkvsc_media_changed(struct gendisk *gd)
+static unsigned int blkvsc_check_events(struct gendisk *gd,
+                                        unsigned int clearing)
 {
         DPRINT_DBG(BLKVSC_DRV, "- enter\n");
-        return 1;
+        return DISK_EVENT_MEDIA_CHANGE;
 }
 
 static int blkvsc_revalidate_disk(struct gendisk *gd)
diff --git a/drivers/staging/westbridge/astoria/block/cyasblkdev_block.c b/drivers/staging/westbridge/astoria/block/cyasblkdev_block.c
index e1851f00be56..842cd9214a5e 100644
--- a/drivers/staging/westbridge/astoria/block/cyasblkdev_block.c
+++ b/drivers/staging/westbridge/astoria/block/cyasblkdev_block.c
@@ -381,10 +381,10 @@ static int cyasblkdev_blk_ioctl(
         return -ENOTTY;
 }
 
-/* Media_changed block_device opp
+/* check_events block_device opp
  * this one is called by kernel to confirm if the media really changed
  * as we indicated by issuing check_disk_change() call */
-int cyasblkdev_media_changed(struct gendisk *gd)
+unsigned int cyasblkdev_check_events(struct gendisk *gd, unsigned int clearing)
 {
         struct cyasblkdev_blk_data *bd;
 
@@ -402,7 +402,7 @@ int cyasblkdev_media_changed(struct gendisk *gd)
                 #endif
         }
 
-        /* return media change state "1" yes, 0 no */
+        /* return media change state - DISK_EVENT_MEDIA_CHANGE yes, 0 no */
         return 0;
 }
 
@@ -432,7 +432,7 @@ static struct block_device_operations cyasblkdev_bdops = {
         .ioctl                  = cyasblkdev_blk_ioctl,
         /* .getgeo              = cyasblkdev_blk_getgeo, */
         /* added to support media removal( real and simulated) media */
-        .media_changed  = cyasblkdev_media_changed,
+        .check_events           = cyasblkdev_check_events,
         /* added to support media removal( real and simulated) media */
         .revalidate_disk = cyasblkdev_revalidate_disk,
         .owner                  = THIS_MODULE,
@@ -1090,6 +1090,7 @@ static int cyasblkdev_add_disks(int bus_num,
                 bd->user_disk_0->first_minor = devidx << CYASBLKDEV_SHIFT;
                 bd->user_disk_0->minors = 8;
                 bd->user_disk_0->fops = &cyasblkdev_bdops;
+                bd->user_disk_0->events = DISK_EVENT_MEDIA_CHANGE;
                 bd->user_disk_0->private_data = bd;
                 bd->user_disk_0->queue = bd->queue.queue;
                 bd->dbgprn_flags = DBGPRN_RD_RQ;
@@ -1190,6 +1191,7 @@ static int cyasblkdev_add_disks(int bus_num,
                 bd->user_disk_1->first_minor = (devidx + 1) << CYASBLKDEV_SHIFT;
                 bd->user_disk_1->minors = 8;
                 bd->user_disk_1->fops = &cyasblkdev_bdops;
+                bd->user_disk_0->events = DISK_EVENT_MEDIA_CHANGE;
                 bd->user_disk_1->private_data = bd;
                 bd->user_disk_1->queue = bd->queue.queue;
                 bd->dbgprn_flags = DBGPRN_RD_RQ;
@@ -1278,6 +1280,7 @@ static int cyasblkdev_add_disks(int bus_num,
                                 (devidx + 2) << CYASBLKDEV_SHIFT;
                         bd->system_disk->minors = 8;
                         bd->system_disk->fops = &cyasblkdev_bdops;
+                        bd->system_disk->events = DISK_EVENT_MEDIA_CHANGE;
                         bd->system_disk->private_data = bd;
                         bd->system_disk->queue = bd->queue.queue;
                         /* don't search for vfat
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 3df570db0e4f..eb0afec046e1 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -391,9 +391,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) {
@@ -411,6 +410,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;
@@ -420,9 +420,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;
 }