Merge branch 'cleanup-bd_claim' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/misc into for-2.6.38/core

10 files changed, 73 insertions, 130 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/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/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 90267f8d64ee..67150c32986c 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/md.c b/drivers/md/md.c
index 324a3663fcda..3bacccab1b8c 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1880,7 +1880,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;
@@ -1907,7 +1907,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;
@@ -1935,19 +1934,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;
@@ -1960,8 +1953,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/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;
         }