Merge branch 'for-2.6.38/core' of git://git.kernel.dk/linux-2.6-block

* 'for-2.6.38/core' of git://git.kernel.dk/linux-2.6-block: (43 commits)
  block: ensure that completion error gets properly traced
  blktrace: add missing probe argument to block_bio_complete
  block cfq: don't use atomic_t for cfq_group
  block cfq: don't use atomic_t for cfq_queue
  block: trace event block fix unassigned field
  block: add internal hd part table references
  block: fix accounting bug on cross partition merges
  kref: add kref_test_and_get
  bio-integrity: mark kintegrityd_wq highpri and CPU intensive
  block: make kblockd_workqueue smarter
  Revert "sd: implement sd_check_events()"
  block: Clean up exit_io_context() source code.
  Fix compile warnings due to missing removal of a 'ret' variable
  fs/block: type signature of major_to_index(int) to major_to_index(unsigned)
  block: convert !IS_ERR(p) && p to !IS_ERR_NOR_NULL(p)
  cfq-iosched: don't check cfqg in choose_service_tree()
  fs/splice: Pull buf->ops->confirm() from splice_from_pipe actors
  cdrom: export cdrom_check_events()
  sd: implement sd_check_events()
  sr: implement sr_check_events()
  ...

18 files changed, 233 insertions, 240 deletions

diff --git a/drivers/block/drbd/drbd_int.h b/drivers/block/drbd/drbd_int.h
index 1ea1a34e78b2..3803a0348937 100644
--- a/drivers/block/drbd/drbd_int.h
+++ b/drivers/block/drbd/drbd_int.h
@@ -911,8 +911,6 @@ struct drbd_md {
 struct drbd_backing_dev {
         struct block_device *backing_bdev;
         struct block_device *md_bdev;
-        struct file *lo_file;
-        struct file *md_file;
         struct drbd_md md;
         struct disk_conf dc; /* The user provided config... */
         sector_t known_size; /* last known size of that backing device */
diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index 6be5401d0e88..29cd0dc9fe4f 100644
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -3372,11 +3372,8 @@ void drbd_free_bc(struct drbd_backing_dev *ldev)
         if (ldev == NULL)
                 return;
 
-        bd_release(ldev->backing_bdev);
-        bd_release(ldev->md_bdev);
-
-        fput(ldev->lo_file);
-        fput(ldev->md_file);
+        blkdev_put(ldev->backing_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
+        blkdev_put(ldev->md_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);
 
         kfree(ldev);
 }
diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index 29e5c70e4e26..8cbfaa687d72 100644
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -855,7 +855,7 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         sector_t max_possible_sectors;
         sector_t min_md_device_sectors;
         struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */
-        struct inode *inode, *inode2;
+        struct block_device *bdev;
         struct lru_cache *resync_lru = NULL;
         union drbd_state ns, os;
         unsigned int max_seg_s;
@@ -907,46 +907,40 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
                 }
         }
 
-        nbc->lo_file = filp_open(nbc->dc.backing_dev, O_RDWR, 0);
-        if (IS_ERR(nbc->lo_file)) {
+        bdev = blkdev_get_by_path(nbc->dc.backing_dev,
+                                  FMODE_READ | FMODE_WRITE | FMODE_EXCL, mdev);
+        if (IS_ERR(bdev)) {
                 dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.backing_dev,
-                    PTR_ERR(nbc->lo_file));
-                nbc->lo_file = NULL;
+                        PTR_ERR(bdev));
                 retcode = ERR_OPEN_DISK;
                 goto fail;
         }
+        nbc->backing_bdev = bdev;
 
-        inode = nbc->lo_file->f_dentry->d_inode;
-
-        if (!S_ISBLK(inode->i_mode)) {
-                retcode = ERR_DISK_NOT_BDEV;
-                goto fail;
-        }
-
-        nbc->md_file = filp_open(nbc->dc.meta_dev, O_RDWR, 0);
-        if (IS_ERR(nbc->md_file)) {
+        /*
+         * meta_dev_idx >= 0: external fixed size, possibly multiple
+         * drbd sharing one meta device.  TODO in that case, paranoia
+         * check that [md_bdev, meta_dev_idx] is not yet used by some
+         * other drbd minor!  (if you use drbd.conf + drbdadm, that
+         * should check it for you already; but if you don't, or
+         * someone fooled it, we need to double check here)
+         */
+        bdev = blkdev_get_by_path(nbc->dc.meta_dev,
+                                  FMODE_READ | FMODE_WRITE | FMODE_EXCL,
+                                  (nbc->dc.meta_dev_idx < 0) ?
+                                  (void *)mdev : (void *)drbd_m_holder);
+        if (IS_ERR(bdev)) {
                 dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.meta_dev,
-                    PTR_ERR(nbc->md_file));
-                nbc->md_file = NULL;
+                        PTR_ERR(bdev));
                 retcode = ERR_OPEN_MD_DISK;
                 goto fail;
         }
+        nbc->md_bdev = bdev;
 
-        inode2 = nbc->md_file->f_dentry->d_inode;
-
-        if (!S_ISBLK(inode2->i_mode)) {
-                retcode = ERR_MD_NOT_BDEV;
-                goto fail;
-        }
-
-        nbc->backing_bdev = inode->i_bdev;
-        if (bd_claim(nbc->backing_bdev, mdev)) {
-                printk(KERN_ERR "drbd: bd_claim(%p,%p); failed [%p;%p;%u]\n",
-                       nbc->backing_bdev, mdev,
-                       nbc->backing_bdev->bd_holder,
-                       nbc->backing_bdev->bd_contains->bd_holder,
-                       nbc->backing_bdev->bd_holders);
-                retcode = ERR_BDCLAIM_DISK;
+        if ((nbc->backing_bdev == nbc->md_bdev) !=
+            (nbc->dc.meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
+             nbc->dc.meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
+                retcode = ERR_MD_IDX_INVALID;
                 goto fail;
         }
 
@@ -955,28 +949,7 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
                         offsetof(struct bm_extent, lce));
         if (!resync_lru) {
                 retcode = ERR_NOMEM;
-                goto release_bdev_fail;
-        }
-
-        /* meta_dev_idx >= 0: external fixed size,
-         * possibly multiple drbd sharing one meta device.
-         * TODO in that case, paranoia check that [md_bdev, meta_dev_idx] is
-         * not yet used by some other drbd minor!
-         * (if you use drbd.conf + drbdadm,
-         * that should check it for you already; but if you don't, or someone
-         * fooled it, we need to double check here) */
-        nbc->md_bdev = inode2->i_bdev;
-        if (bd_claim(nbc->md_bdev, (nbc->dc.meta_dev_idx < 0) ? (void *)mdev
-                                : (void *) drbd_m_holder)) {
-                retcode = ERR_BDCLAIM_MD_DISK;
-                goto release_bdev_fail;
-        }
-
-        if ((nbc->backing_bdev == nbc->md_bdev) !=
-            (nbc->dc.meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
-             nbc->dc.meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
-                retcode = ERR_MD_IDX_INVALID;
-                goto release_bdev2_fail;
+                goto fail;
         }
 
         /* RT - for drbd_get_max_capacity() DRBD_MD_INDEX_FLEX_INT */
@@ -987,7 +960,7 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
                         (unsigned long long) drbd_get_max_capacity(nbc),
                         (unsigned long long) nbc->dc.disk_size);
                 retcode = ERR_DISK_TO_SMALL;
-                goto release_bdev2_fail;
+                goto fail;
         }
 
         if (nbc->dc.meta_dev_idx < 0) {
@@ -1004,7 +977,7 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
                 dev_warn(DEV, "refusing attach: md-device too small, "
                      "at least %llu sectors needed for this meta-disk type\n",
                      (unsigned long long) min_md_device_sectors);
-                goto release_bdev2_fail;
+                goto fail;
         }
 
         /* Make sure the new disk is big enough
@@ -1012,7 +985,7 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         if (drbd_get_max_capacity(nbc) <
             drbd_get_capacity(mdev->this_bdev)) {
                 retcode = ERR_DISK_TO_SMALL;
-                goto release_bdev2_fail;
+                goto fail;
         }
 
         nbc->known_size = drbd_get_capacity(nbc->backing_bdev);
@@ -1035,7 +1008,7 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
         retcode = _drbd_request_state(mdev, NS(disk, D_ATTACHING), CS_VERBOSE);
         drbd_resume_io(mdev);
         if (retcode < SS_SUCCESS)
-                goto release_bdev2_fail;
+                goto fail;
 
         if (!get_ldev_if_state(mdev, D_ATTACHING))
                 goto force_diskless;
@@ -1269,18 +1242,14 @@ static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp
  force_diskless:
         drbd_force_state(mdev, NS(disk, D_FAILED));
         drbd_md_sync(mdev);
- release_bdev2_fail:
-        if (nbc)
-                bd_release(nbc->md_bdev);
- release_bdev_fail:
-        if (nbc)
-                bd_release(nbc->backing_bdev);
  fail:
         if (nbc) {
-                if (nbc->lo_file)
-                        fput(nbc->lo_file);
-                if (nbc->md_file)
-                        fput(nbc->md_file);
+                if (nbc->backing_bdev)
+                        blkdev_put(nbc->backing_bdev,
+                                   FMODE_READ | FMODE_WRITE | FMODE_EXCL);
+                if (nbc->md_bdev)
+                        blkdev_put(nbc->md_bdev,
+                                   FMODE_READ | FMODE_WRITE | FMODE_EXCL);
                 kfree(nbc);
         }
         lc_destroy(resync_lru);
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 7ea0bea2f7e3..44e18c073c44 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -395,11 +395,7 @@ lo_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
         struct loop_device *lo = p->lo;
         struct page *page = buf->page;
         sector_t IV;
-        int size, ret;
-
-        ret = buf->ops->confirm(pipe, buf);
-        if (unlikely(ret))
-                return ret;
+        int size;
 
         IV = ((sector_t) page->index << (PAGE_CACHE_SHIFT - 9)) +
                                                         (buf->offset >> 9);
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 19b3568e9326..77d70eebb6b2 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -2296,15 +2296,12 @@ static int pkt_open_dev(struct pktcdvd_device *pd, fmode_t write)
          * so bdget() can't fail.
          */
         bdget(pd->bdev->bd_dev);
-        if ((ret = blkdev_get(pd->bdev, FMODE_READ)))
+        if ((ret = blkdev_get(pd->bdev, FMODE_READ | FMODE_EXCL, pd)))
                 goto out;
 
-        if ((ret = bd_claim(pd->bdev, pd)))
-                goto out_putdev;
-
         if ((ret = pkt_get_last_written(pd, &lba))) {
                 printk(DRIVER_NAME": pkt_get_last_written failed\n");
-                goto out_unclaim;
+                goto out_putdev;
         }
 
         set_capacity(pd->disk, lba << 2);
@@ -2314,7 +2311,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, fmode_t write)
         q = bdev_get_queue(pd->bdev);
         if (write) {
                 if ((ret = pkt_open_write(pd)))
-                        goto out_unclaim;
+                        goto out_putdev;
                 /*
                  * Some CDRW drives can not handle writes larger than one packet,
                  * even if the size is a multiple of the packet size.
@@ -2329,23 +2326,21 @@ static int pkt_open_dev(struct pktcdvd_device *pd, fmode_t write)
         }
 
         if ((ret = pkt_set_segment_merging(pd, q)))
-                goto out_unclaim;
+                goto out_putdev;
 
         if (write) {
                 if (!pkt_grow_pktlist(pd, CONFIG_CDROM_PKTCDVD_BUFFERS)) {
                         printk(DRIVER_NAME": not enough memory for buffers\n");
                         ret = -ENOMEM;
-                        goto out_unclaim;
+                        goto out_putdev;
                 }
                 printk(DRIVER_NAME": %lukB available on disc\n", lba << 1);
         }
 
         return 0;
 
-out_unclaim:
-        bd_release(pd->bdev);
 out_putdev:
-        blkdev_put(pd->bdev, FMODE_READ);
+        blkdev_put(pd->bdev, FMODE_READ | FMODE_EXCL);
 out:
         return ret;
 }
@@ -2362,8 +2357,7 @@ static void pkt_release_dev(struct pktcdvd_device *pd, int flush)
         pkt_lock_door(pd, 0);
 
         pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
-        bd_release(pd->bdev);
-        blkdev_put(pd->bdev, FMODE_READ);
+        blkdev_put(pd->bdev, FMODE_READ | FMODE_EXCL);
 
         pkt_shrink_pktlist(pd);
 }
@@ -2733,7 +2727,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
         bdev = bdget(dev);
         if (!bdev)
                 return -ENOMEM;
-        ret = blkdev_get(bdev, FMODE_READ | FMODE_NDELAY);
+        ret = blkdev_get(bdev, FMODE_READ | FMODE_NDELAY, NULL);
         if (ret)
                 return ret;
 
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index af13c62dc473..14033a36bcd0 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -1348,7 +1348,10 @@ static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
         if (!CDROM_CAN(CDC_SELECT_DISC))
                 return -EDRIVE_CANT_DO_THIS;
 
-        (void) cdi->ops->media_changed(cdi, slot);
+        if (cdi->ops->check_events)
+                cdi->ops->check_events(cdi, 0, slot);
+        else
+                cdi->ops->media_changed(cdi, slot);
 
         if (slot == CDSL_NONE) {
                 /* set media changed bits, on both queues */
@@ -1392,6 +1395,42 @@ static int cdrom_select_disc(struct cdrom_device_info *cdi, int slot)
         return slot;
 }
 
+/*
+ * As cdrom implements an extra ioctl consumer for media changed
+ * event, it needs to buffer ->check_events() output, such that event
+ * is not lost for both the usual VFS and ioctl paths.
+ * cdi->{vfs|ioctl}_events are used to buffer pending events for each
+ * path.
+ *
+ * XXX: Locking is non-existent.  cdi->ops->check_events() can be
+ * called in parallel and buffering fields are accessed without any
+ * exclusion.  The original media_changed code had the same problem.
+ * It might be better to simply deprecate CDROM_MEDIA_CHANGED ioctl
+ * and remove this cruft altogether.  It doesn't have much usefulness
+ * at this point.
+ */
+static void cdrom_update_events(struct cdrom_device_info *cdi,
+                                unsigned int clearing)
+{
+        unsigned int events;
+
+        events = cdi->ops->check_events(cdi, clearing, CDSL_CURRENT);
+        cdi->vfs_events |= events;
+        cdi->ioctl_events |= events;
+}
+
+unsigned int cdrom_check_events(struct cdrom_device_info *cdi,
+                                unsigned int clearing)
+{
+        unsigned int events;
+
+        cdrom_update_events(cdi, clearing);
+        events = cdi->vfs_events;
+        cdi->vfs_events = 0;
+        return events;
+}
+EXPORT_SYMBOL(cdrom_check_events);
+
 /* We want to make media_changed accessible to the user through an
  * ioctl. The main problem now is that we must double-buffer the
  * low-level implementation, to assure that the VFS and the user both
@@ -1403,15 +1442,26 @@ int media_changed(struct cdrom_device_info *cdi, int queue)
 {
         unsigned int mask = (1 << (queue & 1));
         int ret = !!(cdi->mc_flags & mask);
+        bool changed;
 
         if (!CDROM_CAN(CDC_MEDIA_CHANGED))
-            return ret;
+                return ret;
+
         /* changed since last call? */
-        if (cdi->ops->media_changed(cdi, CDSL_CURRENT)) {
+        if (cdi->ops->check_events) {
+                BUG_ON(!queue); /* shouldn't be called from VFS path */
+                cdrom_update_events(cdi, DISK_EVENT_MEDIA_CHANGE);
+                changed = cdi->ioctl_events & DISK_EVENT_MEDIA_CHANGE;
+                cdi->ioctl_events = 0;
+        } else
+                changed = cdi->ops->media_changed(cdi, CDSL_CURRENT);
+
+        if (changed) {
                 cdi->mc_flags = 0x3;    /* set bit on both queues */
                 ret |= 1;
                 cdi->media_written = 0;
         }
+
         cdi->mc_flags &= ~mask;         /* clear bit */
         return ret;
 }
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index bfe25ea9766b..b4b9d5a47885 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -65,15 +65,12 @@ static int raw_open(struct inode *inode, struct file *filp)
         if (!bdev)
                 goto out;
         igrab(bdev->bd_inode);
-        err = blkdev_get(bdev, filp->f_mode);
+        err = blkdev_get(bdev, filp->f_mode | FMODE_EXCL, raw_open);
         if (err)
                 goto out;
-        err = bd_claim(bdev, raw_open);
-        if (err)
-                goto out1;
         err = set_blocksize(bdev, bdev_logical_block_size(bdev));
         if (err)
-                goto out2;
+                goto out1;
         filp->f_flags |= O_DIRECT;
         filp->f_mapping = bdev->bd_inode->i_mapping;
         if (++raw_devices[minor].inuse == 1)
@@ -83,10 +80,8 @@ static int raw_open(struct inode *inode, struct file *filp)
         mutex_unlock(&raw_mutex);
         return 0;
 
-out2:
-        bd_release(bdev);
 out1:
-        blkdev_put(bdev, filp->f_mode);
+        blkdev_put(bdev, filp->f_mode | FMODE_EXCL);
 out:
         mutex_unlock(&raw_mutex);
         return err;
@@ -110,8 +105,7 @@ static int raw_release(struct inode *inode, struct file *filp)
         }
         mutex_unlock(&raw_mutex);
 
-        bd_release(bdev);
-        blkdev_put(bdev, filp->f_mode);
+        blkdev_put(bdev, filp->f_mode | FMODE_EXCL);
         return 0;
 }
 
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 4d705cea0f8c..985c20a4f30e 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -325,15 +325,18 @@ static int open_dev(struct dm_dev_internal *d, dev_t dev,
 
         BUG_ON(d->dm_dev.bdev);
 
-        bdev = open_by_devnum(dev, d->dm_dev.mode);
+        bdev = blkdev_get_by_dev(dev, d->dm_dev.mode | FMODE_EXCL, _claim_ptr);
         if (IS_ERR(bdev))
                 return PTR_ERR(bdev);
-        r = bd_claim_by_disk(bdev, _claim_ptr, dm_disk(md));
-        if (r)
-                blkdev_put(bdev, d->dm_dev.mode);
-        else
-                d->dm_dev.bdev = bdev;
-        return r;
+
+        r = bd_link_disk_holder(bdev, dm_disk(md));
+        if (r) {
+                blkdev_put(bdev, d->dm_dev.mode | FMODE_EXCL);
+                return r;
+        }
+
+        d->dm_dev.bdev = bdev;
+        return 0;
 }
 
 /*
@@ -344,8 +347,7 @@ static void close_dev(struct dm_dev_internal *d, struct mapped_device *md)
         if (!d->dm_dev.bdev)
                 return;
 
-        bd_release_from_disk(d->dm_dev.bdev, dm_disk(md));
-        blkdev_put(d->dm_dev.bdev, d->dm_dev.mode);
+        blkdev_put(d->dm_dev.bdev, d->dm_dev.mode | FMODE_EXCL);
         d->dm_dev.bdev = NULL;
 }
 
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 7cb1352f7e7a..f48a2f359ac4 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -630,7 +630,7 @@ static void dec_pending(struct dm_io *io, int error)
                         queue_io(md, bio);
                 } else {
                         /* done with normal IO or empty flush */
-                        trace_block_bio_complete(md->queue, bio);
+                        trace_block_bio_complete(md->queue, bio, io_error);
                         bio_endio(bio, io_error);
                 }
         }
@@ -990,8 +990,8 @@ static void __map_bio(struct dm_target *ti, struct bio *clone,
         if (r == DM_MAPIO_REMAPPED) {
                 /* the bio has been remapped so dispatch it */
 
-                trace_block_remap(bdev_get_queue(clone->bi_bdev), clone,
-                                    tio->io->bio->bi_bdev->bd_dev, sector);
+                trace_block_bio_remap(bdev_get_queue(clone->bi_bdev), clone,
+                                      tio->io->bio->bi_bdev->bd_dev, sector);
 
                 generic_make_request(clone);
         } else if (r < 0 || r == DM_MAPIO_REQUEUE) {
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 175c424f201f..7fc090ac9e28 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1879,7 +1879,7 @@ static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
         rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
 
         list_add_rcu(&rdev->same_set, &mddev->disks);
-        bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
+        bd_link_disk_holder(rdev->bdev, mddev->gendisk);
 
         /* May as well allow recovery to be retried once */
         mddev->recovery_disabled = 0;
@@ -1906,7 +1906,6 @@ static void unbind_rdev_from_array(mdk_rdev_t * rdev)
                 MD_BUG();
                 return;
         }
-        bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
         list_del_rcu(&rdev->same_set);
         printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
         rdev->mddev = NULL;
@@ -1934,19 +1933,13 @@ static int lock_rdev(mdk_rdev_t *rdev, dev_t dev, int shared)
         struct block_device *bdev;
         char b[BDEVNAME_SIZE];
 
-        bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
+        bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
+                                 shared ? (mdk_rdev_t *)lock_rdev : rdev);
         if (IS_ERR(bdev)) {
                 printk(KERN_ERR "md: could not open %s.\n",
                         __bdevname(dev, b));
                 return PTR_ERR(bdev);
         }
-        err = bd_claim(bdev, shared ? (mdk_rdev_t *)lock_rdev : rdev);
-        if (err) {
-                printk(KERN_ERR "md: could not bd_claim %s.\n",
-                        bdevname(bdev, b));
-                blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
-                return err;
-        }
         if (!shared)
                 set_bit(AllReserved, &rdev->flags);
         rdev->bdev = bdev;
@@ -1959,8 +1952,7 @@ static void unlock_rdev(mdk_rdev_t *rdev)
         rdev->bdev = NULL;
         if (!bdev)
                 MD_BUG();
-        bd_release(bdev);
-        blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
+        blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
 }
 
 void md_autodetect_dev(dev_t dev);
diff --git a/drivers/mtd/devices/block2mtd.c b/drivers/mtd/devices/block2mtd.c
index 2cf0cc6a4189..f29a6f9df6e7 100644
--- a/drivers/mtd/devices/block2mtd.c
+++ b/drivers/mtd/devices/block2mtd.c
@@ -224,7 +224,7 @@ static void block2mtd_free_device(struct block2mtd_dev *dev)
         if (dev->blkdev) {
                 invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping,
                                         0, -1);
-                close_bdev_exclusive(dev->blkdev, FMODE_READ|FMODE_WRITE);
+                blkdev_put(dev->blkdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
         }
 
         kfree(dev);
@@ -234,6 +234,7 @@ static void block2mtd_free_device(struct block2mtd_dev *dev)
 /* FIXME: ensure that mtd->size % erase_size == 0 */
 static struct block2mtd_dev *add_device(char *devname, int erase_size)
 {
+        const fmode_t mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
         struct block_device *bdev;
         struct block2mtd_dev *dev;
         char *name;
@@ -246,7 +247,7 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
                 return NULL;
 
         /* Get a handle on the device */
-        bdev = open_bdev_exclusive(devname, FMODE_READ|FMODE_WRITE, NULL);
+        bdev = blkdev_get_by_path(devname, mode, dev);
 #ifndef MODULE
         if (IS_ERR(bdev)) {
 
@@ -254,9 +255,8 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
                    to resolve the device name by other means. */
 
                 dev_t devt = name_to_dev_t(devname);
-                if (devt) {
-                        bdev = open_by_devnum(devt, FMODE_WRITE | FMODE_READ);
-                }
+                if (devt)
+                        bdev = blkdev_get_by_dev(devt, mode, dev);
         }
 #endif
 
diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index 30a1ca3d08b7..5505bc07e1e7 100644
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -103,7 +103,7 @@ int dasd_scan_partitions(struct dasd_block *block)
         struct block_device *bdev;
 
         bdev = bdget_disk(block->gdp, 0);
-        if (!bdev || blkdev_get(bdev, FMODE_READ) < 0)
+        if (!bdev || blkdev_get(bdev, FMODE_READ, NULL) < 0)
                 return -ENODEV;
         /*
          * See fs/partition/check.c:register_disk,rescan_partitions
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 501f67bef719..9045c52abd25 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1977,8 +1977,7 @@ EXPORT_SYMBOL(scsi_mode_sense);
  *              in.
  *
  *      Returns zero if unsuccessful or an error if TUR failed.  For
- *      removable media, a return of NOT_READY or UNIT_ATTENTION is
- *      translated to success, with the ->changed flag updated.
+ *      removable media, UNIT_ATTENTION sets ->changed flag.
  **/
 int
 scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries,
@@ -2005,16 +2004,6 @@ scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries,
         } while (scsi_sense_valid(sshdr) &&
                  sshdr->sense_key == UNIT_ATTENTION && --retries);
 
-        if (!sshdr)
-                /* could not allocate sense buffer, so can't process it */
-                return result;
-
-        if (sdev->removable && scsi_sense_valid(sshdr) &&
-            (sshdr->sense_key == UNIT_ATTENTION ||
-             sshdr->sense_key == NOT_READY)) {
-                sdev->changed = 1;
-                result = 0;
-        }
         if (!sshdr_external)
                 kfree(sshdr);
         return result;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 365024b0c407..b65e65aa07eb 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1043,15 +1043,7 @@ static int sd_media_changed(struct gendisk *disk)
                                               sshdr);
         }
 
-        /*
-         * Unable to test, unit probably not ready.   This usually
-         * means there is no disc in the drive.  Mark as changed,
-         * and we will figure it out later once the drive is
-         * available again.
-         */
-        if (retval || (scsi_sense_valid(sshdr) &&
-                       /* 0x3a is medium not present */
-                       sshdr->asc == 0x3a)) {
+        if (retval) {
                 set_media_not_present(sdkp);
                 goto out;
         }
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index d7b383c96d5d..be6baf8ad704 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -104,14 +104,15 @@ static void sr_release(struct cdrom_device_info *);
 static void get_sectorsize(struct scsi_cd *);
 static void get_capabilities(struct scsi_cd *);
 
-static int sr_media_change(struct cdrom_device_info *, int);
+static unsigned int sr_check_events(struct cdrom_device_info *cdi,
+                                    unsigned int clearing, int slot);
 static int sr_packet(struct cdrom_device_info *, struct packet_command *);
 
 static struct cdrom_device_ops sr_dops = {
         .open                   = sr_open,
         .release                = sr_release,
         .drive_status           = sr_drive_status,
-        .media_changed          = sr_media_change,
+        .check_events           = sr_check_events,
         .tray_move              = sr_tray_move,
         .lock_door              = sr_lock_door,
         .select_speed           = sr_select_speed,
@@ -165,90 +166,96 @@ static void scsi_cd_put(struct scsi_cd *cd)
         mutex_unlock(&sr_ref_mutex);
 }
 
-/* identical to scsi_test_unit_ready except that it doesn't
- * eat the NOT_READY returns for removable media */
-int sr_test_unit_ready(struct scsi_device *sdev, struct scsi_sense_hdr *sshdr)
+static unsigned int sr_get_events(struct scsi_device *sdev)
 {
-        int retries = MAX_RETRIES;
-        int the_result;
-        u8 cmd[] = {TEST_UNIT_READY, 0, 0, 0, 0, 0 };
+        u8 buf[8];
+        u8 cmd[] = { GET_EVENT_STATUS_NOTIFICATION,
+                     1,                 /* polled */
+                     0, 0,              /* reserved */
+                     1 << 4,            /* notification class: media */
+                     0, 0,              /* reserved */
+                     0, sizeof(buf),    /* allocation length */
+                     0,                 /* control */
+        };
+        struct event_header *eh = (void *)buf;
+        struct media_event_desc *med = (void *)(buf + 4);
+        struct scsi_sense_hdr sshdr;
+        int result;
 
-        /* issue TEST_UNIT_READY until the initial startup UNIT_ATTENTION
-         * conditions are gone, or a timeout happens
-         */
-        do {
-                the_result = scsi_execute_req(sdev, cmd, DMA_NONE, NULL,
-                                              0, sshdr, SR_TIMEOUT,
-                                              retries--, NULL);
-                if (scsi_sense_valid(sshdr) &&
-                    sshdr->sense_key == UNIT_ATTENTION)
-                        sdev->changed = 1;
-
-        } while (retries > 0 &&
-                 (!scsi_status_is_good(the_result) ||
-                  (scsi_sense_valid(sshdr) &&
-                   sshdr->sense_key == UNIT_ATTENTION)));
-        return the_result;
+        result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buf, sizeof(buf),
+                                  &sshdr, SR_TIMEOUT, MAX_RETRIES, NULL);
+        if (scsi_sense_valid(&sshdr) && sshdr.sense_key == UNIT_ATTENTION)
+                return DISK_EVENT_MEDIA_CHANGE;
+
+        if (result || be16_to_cpu(eh->data_len) < sizeof(*med))
+                return 0;
+
+        if (eh->nea || eh->notification_class != 0x4)
+                return 0;
+
+        if (med->media_event_code == 1)
+                return DISK_EVENT_EJECT_REQUEST;
+        else if (med->media_event_code == 2)
+                return DISK_EVENT_MEDIA_CHANGE;
+        return 0;
 }
 
 /*
- * This function checks to see if the media has been changed in the
- * CDROM drive.  It is possible that we have already sensed a change,
- * or the drive may have sensed one and not yet reported it.  We must
- * be ready for either case. This function always reports the current
- * value of the changed bit.  If flag is 0, then the changed bit is reset.
- * This function could be done as an ioctl, but we would need to have
- * an inode for that to work, and we do not always have one.
+ * This function checks to see if the media has been changed or eject
+ * button has been pressed.  It is possible that we have already
+ * sensed a change, or the drive may have sensed one and not yet
+ * reported it.  The past events are accumulated in sdev->changed and
+ * returned together with the current state.
  */
-
-static int sr_media_change(struct cdrom_device_info *cdi, int slot)
+static unsigned int sr_check_events(struct cdrom_device_info *cdi,
+                                    unsigned int clearing, int slot)
 {
         struct scsi_cd *cd = cdi->handle;
-        int retval;
-        struct scsi_sense_hdr *sshdr;
+        bool last_present;
+        struct scsi_sense_hdr sshdr;
+        unsigned int events;
+        int ret;
 
-        if (CDSL_CURRENT != slot) {
-                /* no changer support */
-                return -EINVAL;
-        }
+        /* no changer support */
+        if (CDSL_CURRENT != slot)
+                return 0;
 
-        sshdr =  kzalloc(sizeof(*sshdr), GFP_KERNEL);
-        retval = sr_test_unit_ready(cd->device, sshdr);
-        if (retval || (scsi_sense_valid(sshdr) &&
-                       /* 0x3a is medium not present */
-                       sshdr->asc == 0x3a)) {
-                /* Media not present or unable to test, unit probably not
-                 * ready. This usually means there is no disc in the drive.
-                 * Mark as changed, and we will figure it out later once
-                 * the drive is available again.
-                 */
-                cd->device->changed = 1;
-                /* This will force a flush, if called from check_disk_change */
-                retval = 1;
-                goto out;
-        };
+        events = sr_get_events(cd->device);
+        /*
+         * GET_EVENT_STATUS_NOTIFICATION is enough unless MEDIA_CHANGE
+         * is being cleared.  Note that there are devices which hang
+         * if asked to execute TUR repeatedly.
+         */
+        if (!(clearing & DISK_EVENT_MEDIA_CHANGE))
+                goto skip_tur;
+
+        /* let's see whether the media is there with TUR */
+        last_present = cd->media_present;
+        ret = scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr);
+
+        /*
+         * Media is considered to be present if TUR succeeds or fails with
+         * sense data indicating something other than media-not-present
+         * (ASC 0x3a).
+         */
+        cd->media_present = scsi_status_is_good(ret) ||
+                (scsi_sense_valid(&sshdr) && sshdr.asc != 0x3a);
 
-        retval = cd->device->changed;
-        cd->device->changed = 0;
-        /* If the disk changed, the capacity will now be different,
-         * so we force a re-read of this information */
-        if (retval) {
-                /* check multisession offset etc */
-                sr_cd_check(cdi);
-                get_sectorsize(cd);
+        if (last_present != cd->media_present)
+                events |= DISK_EVENT_MEDIA_CHANGE;
+skip_tur:
+        if (cd->device->changed) {
+                events |= DISK_EVENT_MEDIA_CHANGE;
+                cd->device->changed = 0;
         }
 
-out:
-        /* Notify userspace, that media has changed. */
-        if (retval != cd->previous_state)
+        /* for backward compatibility */
+        if (events & DISK_EVENT_MEDIA_CHANGE)
                 sdev_evt_send_simple(cd->device, SDEV_EVT_MEDIA_CHANGE,
                                      GFP_KERNEL);
-        cd->previous_state = retval;
-        kfree(sshdr);
-
-        return retval;
+        return events;
 }
- 
+
 /*
  * sr_done is the interrupt routine for the device driver.
  *
@@ -533,10 +540,25 @@ out:
         return ret;
 }
 
-static int sr_block_media_changed(struct gendisk *disk)
+static unsigned int sr_block_check_events(struct gendisk *disk,
+                                          unsigned int clearing)
 {
         struct scsi_cd *cd = scsi_cd(disk);
-        return cdrom_media_changed(&cd->cdi);
+        return cdrom_check_events(&cd->cdi, clearing);
+}
+
+static int sr_block_revalidate_disk(struct gendisk *disk)
+{
+        struct scsi_cd *cd = scsi_cd(disk);
+        struct scsi_sense_hdr sshdr;
+
+        /* if the unit is not ready, nothing more to do */
+        if (scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr))
+                return 0;
+
+        sr_cd_check(&cd->cdi);
+        get_sectorsize(cd);
+        return 0;
 }
 
 static const struct block_device_operations sr_bdops =
@@ -545,7 +567,8 @@ static const struct block_device_operations sr_bdops =
         .open           = sr_block_open,
         .release        = sr_block_release,
         .ioctl          = sr_block_ioctl,
-        .media_changed  = sr_block_media_changed,
+        .check_events   = sr_block_check_events,
+        .revalidate_disk = sr_block_revalidate_disk,
         /* 
          * No compat_ioctl for now because sr_block_ioctl never
          * seems to pass arbitary ioctls down to host drivers.
@@ -618,6 +641,7 @@ static int sr_probe(struct device *dev)
         sprintf(disk->disk_name, "sr%d", minor);
         disk->fops = &sr_bdops;
         disk->flags = GENHD_FL_CD;
+        disk->events = DISK_EVENT_MEDIA_CHANGE | DISK_EVENT_EJECT_REQUEST;
 
         blk_queue_rq_timeout(sdev->request_queue, SR_TIMEOUT);
 
@@ -627,7 +651,7 @@ static int sr_probe(struct device *dev)
         cd->disk = disk;
         cd->capacity = 0x1fffff;
         cd->device->changed = 1;        /* force recheck CD type */
-        cd->previous_state = 1;
+        cd->media_present = 1;
         cd->use = 1;
         cd->readcd_known = 0;
         cd->readcd_cdda = 0;
@@ -780,7 +804,7 @@ static void get_capabilities(struct scsi_cd *cd)
         }
 
         /* eat unit attentions */
-        sr_test_unit_ready(cd->device, &sshdr);
+        scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr);
 
         /* ask for mode page 0x2a */
         rc = scsi_mode_sense(cd->device, 0, 0x2a, buffer, 128,
diff --git a/drivers/scsi/sr.h b/drivers/scsi/sr.h
index 1e144dfdbd4b..e036f1dc83c8 100644
--- a/drivers/scsi/sr.h
+++ b/drivers/scsi/sr.h
@@ -40,7 +40,7 @@ typedef struct scsi_cd {
         unsigned xa_flag:1;     /* CD has XA sectors ? */
         unsigned readcd_known:1;        /* drive supports READ_CD (0xbe) */
         unsigned readcd_cdda:1; /* reading audio data using READ_CD */
-        unsigned previous_state:1;      /* media has changed */
+        unsigned media_present:1;       /* media is present */
         struct cdrom_device_info cdi;
         /* We hold gendisk and scsi_device references on probe and use
          * the refs on this kref to decide when to release them */
@@ -61,7 +61,6 @@ int sr_select_speed(struct cdrom_device_info *cdi, int speed);
 int sr_audio_ioctl(struct cdrom_device_info *, unsigned int, void *);
 
 int sr_is_xa(Scsi_CD *);
-int sr_test_unit_ready(struct scsi_device *sdev, struct scsi_sense_hdr *sshdr);
 
 /* sr_vendor.c */
 void sr_vendor_init(Scsi_CD *);
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index 3cd8ffbad577..8be30554119b 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -307,7 +307,7 @@ int sr_drive_status(struct cdrom_device_info *cdi, int slot)
                 /* we have no changer support */
                 return -EINVAL;
         }
-        if (0 == sr_test_unit_ready(cd->device, &sshdr))
+        if (!scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr))
                 return CDS_DISC_OK;
 
         /* SK/ASC/ASCQ of 2/4/1 means "unit is becoming ready" */
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index 3b513bafaf2a..b015561fd602 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -543,7 +543,7 @@ static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
         ro = curlun->initially_ro;
         if (!ro) {
                 filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
-                if (-EROFS == PTR_ERR(filp))
+                if (PTR_ERR(filp) == -EROFS || PTR_ERR(filp) == -EACCES)
                         ro = 1;
         }
         if (ro)
@@ -558,10 +558,7 @@ static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
 
         if (filp->f_path.dentry)
                 inode = filp->f_path.dentry->d_inode;
-        if (inode && S_ISBLK(inode->i_mode)) {
-                if (bdev_read_only(inode->i_bdev))
-                        ro = 1;
-        } else if (!inode || !S_ISREG(inode->i_mode)) {
+        if (!inode || (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))) {
                 LINFO(curlun, "invalid file type: %s\n", filename);
                 goto out;
         }