block/bdev.c: use the knowledge of inode/bdev coallocation

Here we know that bdevfs inodes are coallocated with struct block_device
and we can get to ->bd_inode value without any dereferencing.  Introduce
an inlined helper (static, *not* exported, purely internal for bdev.c)
that gets an associated inode by block_device - BD_INODE(bdev).

NOTE: leave it static; nobody outside of block/bdev.c has any business
playing with that.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/block/bdev.c b/block/bdev.c
index 00017af92a51dc2f1b5ac9c90bb820b7ad43ac75..a8c66cc1d6b893cc8b3f9699920f5b74e17a965f 100644 (file)
--- a/block/bdev.c
+++ b/block/bdev.c
@@ -43,6 +43,11 @@ static inline struct bdev_inode *BDEV_I(struct inode *inode)
        return container_of(inode, struct bdev_inode, vfs_inode);
 }
 
+static inline struct inode *BD_INODE(struct block_device *bdev)
+{
+       return &container_of(bdev, struct bdev_inode, bdev)->vfs_inode;
+}
+
 struct block_device *I_BDEV(struct inode *inode)
 {
        return &BDEV_I(inode)->bdev;
@@ -57,7 +62,7 @@ EXPORT_SYMBOL(file_bdev);
 
 static void bdev_write_inode(struct block_device *bdev)
 {
-       struct inode *inode = bdev->bd_inode;
+       struct inode *inode = BD_INODE(bdev);
        int ret;
 
        spin_lock(&inode->i_lock);
@@ -134,14 +139,14 @@ invalidate:
 static void set_init_blocksize(struct block_device *bdev)
 {
        unsigned int bsize = bdev_logical_block_size(bdev);
-       loff_t size = i_size_read(bdev->bd_inode);
+       loff_t size = i_size_read(BD_INODE(bdev));
 
        while (bsize < PAGE_SIZE) {
                if (size & bsize)
                        break;
                bsize <<= 1;
        }
-       bdev->bd_inode->i_blkbits = blksize_bits(bsize);
+       BD_INODE(bdev)->i_blkbits = blksize_bits(bsize);
 }
 
 int set_blocksize(struct file *file, int size)
@@ -437,29 +442,30 @@ struct block_device *bdev_alloc(struct gendisk *disk, u8 partno)
 void bdev_set_nr_sectors(struct block_device *bdev, sector_t sectors)
 {
        spin_lock(&bdev->bd_size_lock);
-       i_size_write(bdev->bd_inode, (loff_t)sectors << SECTOR_SHIFT);
+       i_size_write(BD_INODE(bdev), (loff_t)sectors << SECTOR_SHIFT);
        bdev->bd_nr_sectors = sectors;
        spin_unlock(&bdev->bd_size_lock);
 }
 
 void bdev_add(struct block_device *bdev, dev_t dev)
 {
+       struct inode *inode = BD_INODE(bdev);
        if (bdev_stable_writes(bdev))
                mapping_set_stable_writes(bdev->bd_mapping);
        bdev->bd_dev = dev;
-       bdev->bd_inode->i_rdev = dev;
-       bdev->bd_inode->i_ino = dev;
-       insert_inode_hash(bdev->bd_inode);
+       inode->i_rdev = dev;
+       inode->i_ino = dev;
+       insert_inode_hash(inode);
 }
 
 void bdev_unhash(struct block_device *bdev)
 {
-       remove_inode_hash(bdev->bd_inode);
+       remove_inode_hash(BD_INODE(bdev));
 }
 
 void bdev_drop(struct block_device *bdev)
 {
-       iput(bdev->bd_inode);
+       iput(BD_INODE(bdev));
 }
 
 long nr_blockdev_pages(void)
@@ -987,13 +993,13 @@ struct file *bdev_file_open_by_dev(dev_t dev, blk_mode_t mode, void *holder,
                return ERR_PTR(-ENXIO);
 
        flags = blk_to_file_flags(mode);
-       bdev_file = alloc_file_pseudo_noaccount(bdev->bd_inode,
+       bdev_file = alloc_file_pseudo_noaccount(BD_INODE(bdev),
                        blockdev_mnt, "", flags | O_LARGEFILE, &def_blk_fops);
        if (IS_ERR(bdev_file)) {
                blkdev_put_no_open(bdev);
                return bdev_file;
        }
-       ihold(bdev->bd_inode);
+       ihold(BD_INODE(bdev));
 
        ret = bdev_open(bdev, mode, holder, hops, bdev_file);
        if (ret) {
@@ -1270,13 +1276,13 @@ void bdev_statx_dioalign(struct inode *inode, struct kstat *stat)
 
 bool disk_live(struct gendisk *disk)
 {
-       return !inode_unhashed(disk->part0->bd_inode);
+       return !inode_unhashed(BD_INODE(disk->part0));
 }
 EXPORT_SYMBOL_GPL(disk_live);
 
 unsigned int block_size(struct block_device *bdev)
 {
-       return 1 << bdev->bd_inode->i_blkbits;
+       return 1 << BD_INODE(bdev)->i_blkbits;
 }
 EXPORT_SYMBOL_GPL(block_size);