block: refactor __blkdev_put

[linux-2.6-microblaze.git] / fs / block_dev.c

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 9e84b19..6016777 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -548,55 +548,47 @@ EXPORT_SYMBOL(fsync_bdev);
  * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
  * actually.
  */
-struct super_block *freeze_bdev(struct block_device *bdev)
+int freeze_bdev(struct block_device *bdev)
 {
        struct super_block *sb;
        int error = 0;
 
        mutex_lock(&bdev->bd_fsfreeze_mutex);
-       if (++bdev->bd_fsfreeze_count > 1) {
-               /*
-                * We don't even need to grab a reference - the first call
-                * to freeze_bdev grab an active reference and only the last
-                * thaw_bdev drops it.
-                */
-               sb = get_super(bdev);
-               if (sb)
-                       drop_super(sb);
-               mutex_unlock(&bdev->bd_fsfreeze_mutex);
-               return sb;
-       }
+       if (++bdev->bd_fsfreeze_count > 1)
+               goto done;
 
        sb = get_active_super(bdev);
        if (!sb)
-               goto out;
+               goto sync;
        if (sb->s_op->freeze_super)
                error = sb->s_op->freeze_super(sb);
        else
                error = freeze_super(sb);
+       deactivate_super(sb);
+
        if (error) {
-               deactivate_super(sb);
                bdev->bd_fsfreeze_count--;
-               mutex_unlock(&bdev->bd_fsfreeze_mutex);
-               return ERR_PTR(error);
+               goto done;
        }
-       deactivate_super(sb);
- out:
+       bdev->bd_fsfreeze_sb = sb;
+
+sync:
        sync_blockdev(bdev);
+done:
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
-       return sb;      /* thaw_bdev releases s->s_umount */
+       return error;
 }
 EXPORT_SYMBOL(freeze_bdev);
 
 /**
  * thaw_bdev  -- unlock filesystem
  * @bdev:      blockdevice to unlock
- * @sb:                associated superblock
  *
  * Unlocks the filesystem and marks it writeable again after freeze_bdev().
  */
-int thaw_bdev(struct block_device *bdev, struct super_block *sb)
+int thaw_bdev(struct block_device *bdev)
 {
+       struct super_block *sb;
        int error = -EINVAL;
 
        mutex_lock(&bdev->bd_fsfreeze_mutex);
@@ -607,6 +599,7 @@ int thaw_bdev(struct block_device *bdev, struct super_block *sb)
        if (--bdev->bd_fsfreeze_count > 0)
                goto out;
 
+       sb = bdev->bd_fsfreeze_sb;
        if (!sb)
                goto out;
 
@@ -870,35 +863,12 @@ void __init bdev_cache_init(void)
        blockdev_superblock = bd_mnt->mnt_sb;   /* For writeback */
 }
 
-/*
- * Most likely _very_ bad one - but then it's hardly critical for small
- * /dev and can be fixed when somebody will need really large one.
- * Keep in mind that it will be fed through icache hash function too.
- */
-static inline unsigned long hash(dev_t dev)
-{
-       return MAJOR(dev)+MINOR(dev);
-}
-
-static int bdev_test(struct inode *inode, void *data)
-{
-       return BDEV_I(inode)->bdev.bd_dev == *(dev_t *)data;
-}
-
-static int bdev_set(struct inode *inode, void *data)
-{
-       BDEV_I(inode)->bdev.bd_dev = *(dev_t *)data;
-       return 0;
-}
-
 static struct block_device *bdget(dev_t dev)
 {
        struct block_device *bdev;
        struct inode *inode;
 
-       inode = iget5_locked(blockdev_superblock, hash(dev),
-                       bdev_test, bdev_set, &dev);
-
+       inode = iget_locked(blockdev_superblock, dev);
        if (!inode)
                return NULL;
 
@@ -910,6 +880,7 @@ static struct block_device *bdget(dev_t dev)
                bdev->bd_super = NULL;
                bdev->bd_inode = inode;
                bdev->bd_part_count = 0;
+               bdev->bd_dev = dev;
                inode->i_mode = S_IFBLK;
                inode->i_rdev = dev;
                inode->i_bdev = bdev;
@@ -923,10 +894,14 @@ static struct block_device *bdget(dev_t dev)
 /**
  * bdgrab -- Grab a reference to an already referenced block device
  * @bdev:      Block device to grab a reference to.
+ *
+ * Returns the block_device with an additional reference when successful,
+ * or NULL if the inode is already beeing freed.
  */
 struct block_device *bdgrab(struct block_device *bdev)
 {
-       ihold(bdev->bd_inode);
+       if (!igrab(bdev->bd_inode))
+               return NULL;
        return bdev;
 }
 EXPORT_SYMBOL(bdgrab);
@@ -1249,7 +1224,7 @@ int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk)
        holder->disk = disk;
        holder->refcnt = 1;
 
-       ret = add_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
+       ret = add_symlink(disk->slave_dir, bdev_kobj(bdev));
        if (ret)
                goto out_free;
 
@@ -1266,7 +1241,7 @@ int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk)
        goto out_unlock;
 
 out_del:
-       del_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
+       del_symlink(disk->slave_dir, bdev_kobj(bdev));
 out_free:
        kfree(holder);
 out_unlock:
@@ -1294,7 +1269,7 @@ void bd_unlink_disk_holder(struct block_device *bdev, struct gendisk *disk)
        holder = bd_find_holder_disk(bdev, disk);
 
        if (!WARN_ON_ONCE(holder == NULL) && !--holder->refcnt) {
-               del_symlink(disk->slave_dir, &part_to_dev(bdev->bd_part)->kobj);
+               del_symlink(disk->slave_dir, bdev_kobj(bdev));
                del_symlink(bdev->bd_part->holder_dir,
                            &disk_to_dev(disk)->kobj);
                kobject_put(bdev->bd_part->holder_dir);
@@ -1334,12 +1309,6 @@ static void check_disk_size_change(struct gendisk *disk,
                i_size_write(bdev->bd_inode, disk_size);
        }
        spin_unlock(&bdev->bd_size_lock);
-
-       if (bdev_size > disk_size) {
-               if (__invalidate_device(bdev, false))
-                       pr_warn("VFS: busy inodes on resized disk %s\n",
-                               disk->disk_name);
-       }
 }
 
 /**
@@ -1368,7 +1337,6 @@ void revalidate_disk_size(struct gendisk *disk, bool verbose)
                bdput(bdev);
        }
 }
-EXPORT_SYMBOL(revalidate_disk_size);
 
 void bd_set_nr_sectors(struct block_device *bdev, sector_t sectors)
 {
@@ -1774,22 +1742,22 @@ static void __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
                WARN_ON_ONCE(bdev->bd_holders);
                sync_blockdev(bdev);
                kill_bdev(bdev);
-
                bdev_write_inode(bdev);
-       }
-       if (bdev->bd_contains == bdev) {
-               if (disk->fops->release)
+
+               if (!bdev_is_partition(bdev) && disk->fops->release)
                        disk->fops->release(disk, mode);
-       }
-       if (!bdev->bd_openers) {
+
                disk_put_part(bdev->bd_part);
                bdev->bd_part = NULL;
                bdev->bd_disk = NULL;
-               if (bdev != bdev->bd_contains)
+               if (bdev_is_partition(bdev))
                        victim = bdev->bd_contains;
                bdev->bd_contains = NULL;
 
                put_disk_and_module(disk);
+       } else {
+               if (!bdev_is_partition(bdev) && disk->fops->release)
+                       disk->fops->release(disk, mode);
        }
        mutex_unlock(&bdev->bd_mutex);
        bdput(bdev);