fs: add i_blocksize()

commit 93407472a21b82f39c955ea7787e5bc7da100642 upstream.

Replace all 1 << inode->i_blkbits and (1 << inode->i_blkbits) in fs
branch.

This patch also fixes multiple checkpatch warnings: WARNING: Prefer
'unsigned int' to bare use of 'unsigned'

Thanks to Andrew Morton for suggesting more appropriate function instead
of macro.

[geliangtang@gmail.com: truncate: use i_blocksize()]
Link: http://lkml.kernel.org/r/9c8b2cd83c8f5653805d43debde9fa8817e02fc4.1484895804.git.geliangtang@gmail.com
Link: http://lkml.kernel.org/r/1481319905-10126-1-git-send-email-fabf@skynet.be
Signed-off-by: Fabian Frederick <fabf@skynet.be>
Signed-off-by: Geliang Tang <geliangtang@gmail.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 353f4bae658c570002e6ea9504443044a238e96e..d4a6eef318545780af813274adb74f7d70d55fae 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -2771,7 +2771,7 @@ static long btrfs_fallocate(struct file *file, int mode,
                if (!ret)
                        ret = btrfs_prealloc_file_range(inode, mode,
                                        range->start,
-                                       range->len, 1 << inode->i_blkbits,
+                                       range->len, i_blocksize(inode),
                                        offset + len, &alloc_hint);
                list_del(&range->list);
                kfree(range);

diff --git a/fs/buffer.c b/fs/buffer.c
index 4f4cd959da7c8fdfef9fcf49fd90e73c24c6d230..6f7d519a093b2c69e51280483ac326cd1ec2cd5e 100644 (file)
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2298,7 +2298,7 @@ static int cont_expand_zero(struct file *file, struct address_space *mapping,
                            loff_t pos, loff_t *bytes)
 {
        struct inode *inode = mapping->host;
-       unsigned blocksize = 1 << inode->i_blkbits;
+       unsigned int blocksize = i_blocksize(inode);
        struct page *page;
        void *fsdata;
        pgoff_t index, curidx;
@@ -2378,8 +2378,8 @@ int cont_write_begin(struct file *file, struct address_space *mapping,
                        get_block_t *get_block, loff_t *bytes)
 {
        struct inode *inode = mapping->host;
-       unsigned blocksize = 1 << inode->i_blkbits;
-       unsigned zerofrom;
+       unsigned int blocksize = i_blocksize(inode);
+       unsigned int zerofrom;
        int err;
 
        err = cont_expand_zero(file, mapping, pos, bytes);
@@ -2741,7 +2741,7 @@ int nobh_truncate_page(struct address_space *mapping,
        struct buffer_head map_bh;
        int err;
 
-       blocksize = 1 << inode->i_blkbits;
+       blocksize = i_blocksize(inode);
        length = offset & (blocksize - 1);
 
        /* Block boundary? Nothing to do */
@@ -2819,7 +2819,7 @@ int block_truncate_page(struct address_space *mapping,
        struct buffer_head *bh;
        int err;
 
-       blocksize = 1 << inode->i_blkbits;
+       blocksize = i_blocksize(inode);
        length = offset & (blocksize - 1);
 
        /* Block boundary? Nothing to do */
@@ -2931,7 +2931,7 @@ sector_t generic_block_bmap(struct address_space *mapping, sector_t block,
        struct inode *inode = mapping->host;
        tmp.b_state = 0;
        tmp.b_blocknr = 0;
-       tmp.b_size = 1 << inode->i_blkbits;
+       tmp.b_size = i_blocksize(inode);
        get_block(inode, block, &tmp, 0);
        return tmp.b_blocknr;
 }

diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index b7d218a168fb81c2c028ea38ffccf2a17a1d68d5..c6a1ec110c015c82784b17b55353015a63061796 100644 (file)
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -697,7 +697,7 @@ static int ceph_writepages_start(struct address_space *mapping,
        struct pagevec pvec;
        int done = 0;
        int rc = 0;
-       unsigned wsize = 1 << inode->i_blkbits;
+       unsigned int wsize = i_blocksize(inode);
        struct ceph_osd_request *req = NULL;
        int do_sync = 0;
        loff_t snap_size, i_size;

diff --git a/fs/direct-io.c b/fs/direct-io.c
index 01171d8a6ee94fea8ad7ff02015426ad156b3197..c772fdf36cd914885c358d9ba56930038e326e17 100644 (file)
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -575,7 +575,7 @@ static int dio_set_defer_completion(struct dio *dio)
 /*
  * Call into the fs to map some more disk blocks.  We record the current number
  * of available blocks at sdio->blocks_available.  These are in units of the
- * fs blocksize, (1 << inode->i_blkbits).
+ * fs blocksize, i_blocksize(inode).
  *
  * The fs is allowed to map lots of blocks at once.  If it wants to do that,
  * it uses the passed inode-relative block number as the file offset, as usual.

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 801c32ef9047a8d5d6de8aa08246766102368bf3..1796d1bd9a1d26cb8f74e8117b49ef5f1bec0d1b 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -2044,7 +2044,7 @@ static int mpage_process_page_bufs(struct mpage_da_data *mpd,
 {
        struct inode *inode = mpd->inode;
        int err;
-       ext4_lblk_t blocks = (i_size_read(inode) + (1 << inode->i_blkbits) - 1)
+       ext4_lblk_t blocks = (i_size_read(inode) + i_blocksize(inode) - 1)
                                                        >> inode->i_blkbits;
 
        do {

diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c
index 7861d801b048e5d47143c2a3d9d6148cf8a6c971..05048fcfd602cdca1c24bbbc03de7c0174740a19 100644 (file)
--- a/fs/ext4/move_extent.c
+++ b/fs/ext4/move_extent.c
@@ -187,7 +187,7 @@ mext_page_mkuptodate(struct page *page, unsigned from, unsigned to)
        if (PageUptodate(page))
                return 0;
 
-       blocksize = 1 << inode->i_blkbits;
+       blocksize = i_blocksize(inode);
        if (!page_has_buffers(page))
                create_empty_buffers(page, blocksize, 0);
 

diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 8f9176caf098c559bbe3c9975b2dff9fffb0ffb4..c8d58c5ac8aec6872bc9b5142b788153d2298a36 100644 (file)
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -758,7 +758,7 @@ static ssize_t jfs_quota_read(struct super_block *sb, int type, char *data,
                                sb->s_blocksize - offset : toread;
 
                tmp_bh.b_state = 0;
-               tmp_bh.b_size = 1 << inode->i_blkbits;
+               tmp_bh.b_size = i_blocksize(inode);
                err = jfs_get_block(inode, blk, &tmp_bh, 0);
                if (err)
                        return err;
@@ -798,7 +798,7 @@ static ssize_t jfs_quota_write(struct super_block *sb, int type,
                                sb->s_blocksize - offset : towrite;
 
                tmp_bh.b_state = 0;
-               tmp_bh.b_size = 1 << inode->i_blkbits;
+               tmp_bh.b_size = i_blocksize(inode);
                err = jfs_get_block(inode, blk, &tmp_bh, 1);
                if (err)
                        goto out;

diff --git a/fs/mpage.c b/fs/mpage.c
index 1480d3a180370fe3922a7724e613d09b896f9d00..6ade29b194941ddcfbf03eeebfe91c6cca1cfbb3 100644 (file)
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -111,7 +111,7 @@ map_buffer_to_page(struct page *page, struct buffer_head *bh, int page_block)
                        SetPageUptodate(page);    
                        return;
                }
-               create_empty_buffers(page, 1 << inode->i_blkbits, 0);
+               create_empty_buffers(page, i_blocksize(inode), 0);
        }
        head = page_buffers(page);
        page_bh = head;

diff --git a/fs/nfsd/blocklayout.c b/fs/nfsd/blocklayout.c
index c29d9421bd5e1f8c890178c6ec961899b319ceef..0976f8dad4ce217d2c6a843b798239f03d122500 100644 (file)
--- a/fs/nfsd/blocklayout.c
+++ b/fs/nfsd/blocklayout.c
@@ -50,7 +50,7 @@ nfsd4_block_proc_layoutget(struct inode *inode, const struct svc_fh *fhp,
 {
        struct nfsd4_layout_seg *seg = &args->lg_seg;
        struct super_block *sb = inode->i_sb;
-       u32 block_size = (1 << inode->i_blkbits);
+       u32 block_size = i_blocksize(inode);
        struct pnfs_block_extent *bex;
        struct iomap iomap;
        u32 device_generation = 0;
@@ -151,7 +151,7 @@ nfsd4_block_proc_layoutcommit(struct inode *inode,
        int error;
 
        nr_iomaps = nfsd4_block_decode_layoutupdate(lcp->lc_up_layout,
-                       lcp->lc_up_len, &iomaps, 1 << inode->i_blkbits);
+                       lcp->lc_up_len, &iomaps, i_blocksize(inode));
        if (nr_iomaps < 0)
                return nfserrno(nr_iomaps);
 

diff --git a/fs/nilfs2/btnode.c b/fs/nilfs2/btnode.c
index a35ae35e69320f711454125f9a600586869bb980..cd39b57288c2e6c97b45447fa498075c12aad8a9 100644 (file)
--- a/fs/nilfs2/btnode.c
+++ b/fs/nilfs2/btnode.c
@@ -55,7 +55,7 @@ nilfs_btnode_create_block(struct address_space *btnc, __u64 blocknr)
                brelse(bh);
                BUG();
        }
-       memset(bh->b_data, 0, 1 << inode->i_blkbits);
+       memset(bh->b_data, 0, i_blocksize(inode));
        bh->b_bdev = inode->i_sb->s_bdev;
        bh->b_blocknr = blocknr;
        set_buffer_mapped(bh);

diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index ac2f64943ff4c257f3fe2cd8d32de581de601cc6..00877ef0b120f6fabb6b086824f1842ac166ac73 100644 (file)
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -55,7 +55,7 @@ void nilfs_inode_add_blocks(struct inode *inode, int n)
 {
        struct nilfs_root *root = NILFS_I(inode)->i_root;
 
-       inode_add_bytes(inode, (1 << inode->i_blkbits) * n);
+       inode_add_bytes(inode, i_blocksize(inode) * n);
        if (root)
                atomic64_add(n, &root->blocks_count);
 }
@@ -64,7 +64,7 @@ void nilfs_inode_sub_blocks(struct inode *inode, int n)
 {
        struct nilfs_root *root = NILFS_I(inode)->i_root;
 
-       inode_sub_bytes(inode, (1 << inode->i_blkbits) * n);
+       inode_sub_bytes(inode, i_blocksize(inode) * n);
        if (root)
                atomic64_sub(n, &root->blocks_count);
 }

diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index 1125f40233ffd9c849acc0f13d432f520de95e0a..612a2457243d6144f317abd4c0514e3f18ff6c49 100644 (file)
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -60,7 +60,7 @@ nilfs_mdt_insert_new_block(struct inode *inode, unsigned long block,
        set_buffer_mapped(bh);
 
        kaddr = kmap_atomic(bh->b_page);
-       memset(kaddr + bh_offset(bh), 0, 1 << inode->i_blkbits);
+       memset(kaddr + bh_offset(bh), 0, i_blocksize(inode));
        if (init_block)
                init_block(inode, bh, kaddr);
        flush_dcache_page(bh->b_page);
@@ -503,7 +503,7 @@ void nilfs_mdt_set_entry_size(struct inode *inode, unsigned entry_size,
        struct nilfs_mdt_info *mi = NILFS_MDT(inode);
 
        mi->mi_entry_size = entry_size;
-       mi->mi_entries_per_block = (1 << inode->i_blkbits) / entry_size;
+       mi->mi_entries_per_block = i_blocksize(inode) / entry_size;
        mi->mi_first_entry_offset = DIV_ROUND_UP(header_size, entry_size);
 }
 

diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 3b65adaae7e47b9732669c4db8a563cfeeec4d87..2f27c935bd574712d67f47f99032a00deda4455f 100644 (file)
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -719,7 +719,7 @@ static size_t nilfs_lookup_dirty_data_buffers(struct inode *inode,
 
                lock_page(page);
                if (!page_has_buffers(page))
-                       create_empty_buffers(page, 1 << inode->i_blkbits, 0);
+                       create_empty_buffers(page, i_blocksize(inode), 0);
                unlock_page(page);
 
                bh = head = page_buffers(page);

diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index e6795c7c76a854b39441381bdce5fed147bb1a53..e4184bd2a95493302fb6ec7efd8c3f7e038aa431 100644 (file)
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -1103,7 +1103,7 @@ int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
        int ret = 0;
        struct buffer_head *head, *bh, *wait[2], **wait_bh = wait;
        unsigned int block_end, block_start;
-       unsigned int bsize = 1 << inode->i_blkbits;
+       unsigned int bsize = i_blocksize(inode);
 
        if (!page_has_buffers(page))
                create_empty_buffers(page, bsize, 0);

diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 56dd3957cc91c058e41dea9b9936f4dcf871d623..1d738723a41adaf584d18f77534f1576640f0450 100644 (file)
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -808,7 +808,7 @@ static int ocfs2_write_zero_page(struct inode *inode, u64 abs_from,
        /* We know that zero_from is block aligned */
        for (block_start = zero_from; block_start < zero_to;
             block_start = block_end) {
-               block_end = block_start + (1 << inode->i_blkbits);
+               block_end = block_start + i_blocksize(inode);
 
                /*
                 * block_start is block-aligned.  Bump it by one to force

diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 8f5ccdf81c252f9d9eddc24ed301f9bacac9901b..38187300a2b45463933609657dafaeabcf616f08 100644 (file)
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -189,7 +189,7 @@ int reiserfs_commit_page(struct inode *inode, struct page *page,
        int ret = 0;
 
        th.t_trans_id = 0;
-       blocksize = 1 << inode->i_blkbits;
+       blocksize = i_blocksize(inode);
 
        if (logit) {
                reiserfs_write_lock(s);

diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 3d8e7e671d5ba7d15fe4a14e1b803673c220cdee..60ba35087d12697eb9bc80c03073fc840edc9b2e 100644 (file)
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -524,7 +524,7 @@ static int reiserfs_get_blocks_direct_io(struct inode *inode,
         * referenced in convert_tail_for_hole() that may be called from
         * reiserfs_get_block()
         */
-       bh_result->b_size = (1 << inode->i_blkbits);
+       bh_result->b_size = i_blocksize(inode);
 
        ret = reiserfs_get_block(inode, iblock, bh_result,
                                 create | GET_BLOCK_NO_DANGLE);

diff --git a/fs/stat.c b/fs/stat.c
index d4a61d8dc021e6e70a3a1317ef793753de8165ed..36abb5061b722fbbafeb77b1e013919f57970918 100644 (file)
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -31,7 +31,7 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
        stat->atime = inode->i_atime;
        stat->mtime = inode->i_mtime;
        stat->ctime = inode->i_ctime;
-       stat->blksize = (1 << inode->i_blkbits);
+       stat->blksize = i_blocksize(inode);
        stat->blocks = inode->i_blocks;
 }
 

diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 566df9b5a6cb6db53cd375e5211299d7fa6e92e3..7be3166ba553675a8eedca5d26c1757780fcca23 100644 (file)
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -1206,7 +1206,7 @@ int udf_setsize(struct inode *inode, loff_t newsize)
 {
        int err;
        struct udf_inode_info *iinfo;
-       int bsize = 1 << inode->i_blkbits;
+       int bsize = i_blocksize(inode);
 
        if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
              S_ISLNK(inode->i_mode)))

diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 29e7e5dd5178ef84638752f31ce6149c64398061..187b80267ff938504ac087e1166d8147b6f8aacc 100644 (file)
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -288,7 +288,7 @@ xfs_map_blocks(
 {
        struct xfs_inode        *ip = XFS_I(inode);
        struct xfs_mount        *mp = ip->i_mount;
-       ssize_t                 count = 1 << inode->i_blkbits;
+       ssize_t                 count = i_blocksize(inode);
        xfs_fileoff_t           offset_fsb, end_fsb;
        int                     error = 0;
        int                     bmapi_flags = XFS_BMAPI_ENTIRE;
@@ -921,7 +921,7 @@ xfs_aops_discard_page(
                        break;
                }
 next_buffer:
-               offset += 1 << inode->i_blkbits;
+               offset += i_blocksize(inode);
 
        } while ((bh = bh->b_this_page) != head);
 
@@ -1363,7 +1363,7 @@ xfs_map_trim_size(
            offset + mapping_size >= i_size_read(inode)) {
                /* limit mapping to block that spans EOF */
                mapping_size = roundup_64(i_size_read(inode) - offset,
-                                         1 << inode->i_blkbits);
+                                         i_blocksize(inode));
        }
        if (mapping_size > LONG_MAX)
                mapping_size = LONG_MAX;
@@ -1395,7 +1395,7 @@ __xfs_get_blocks(
                return -EIO;
 
        offset = (xfs_off_t)iblock << inode->i_blkbits;
-       ASSERT(bh_result->b_size >= (1 << inode->i_blkbits));
+       ASSERT(bh_result->b_size >= i_blocksize(inode));
        size = bh_result->b_size;
 
        if (!create && direct && offset >= i_size_read(inode))
@@ -1968,7 +1968,7 @@ xfs_vm_set_page_dirty(
                        if (offset < end_offset)
                                set_buffer_dirty(bh);
                        bh = bh->b_this_page;
-                       offset += 1 << inode->i_blkbits;
+                       offset += i_blocksize(inode);
                } while (bh != head);
        }
        /*

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index ceea444dafb46c231d75fa01311f680740c9ee1d..3dd47307363fa891b37f32a42de82b39e1e8efa6 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -947,7 +947,7 @@ xfs_file_fallocate(
                if (error)
                        goto out_unlock;
        } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
-               unsigned blksize_mask = (1 << inode->i_blkbits) - 1;
+               unsigned int blksize_mask = i_blocksize(inode) - 1;
 
                if (offset & blksize_mask || len & blksize_mask) {
                        error = -EINVAL;
@@ -969,7 +969,7 @@ xfs_file_fallocate(
                if (error)
                        goto out_unlock;
        } else if (mode & FALLOC_FL_INSERT_RANGE) {
-               unsigned blksize_mask = (1 << inode->i_blkbits) - 1;
+               unsigned int blksize_mask = i_blocksize(inode) - 1;
 
                new_size = i_size_read(inode) + len;
                if (offset & blksize_mask || len & blksize_mask) {

diff --git a/include/linux/fs.h b/include/linux/fs.h
index e1a123760dbfce85fd796a20a1c66427d71126b8..c8decb7075d65728fe816cdceec30e38e25dda37 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -680,6 +680,11 @@ struct inode {
        void                    *i_private; /* fs or device private pointer */
 };
 
+static inline unsigned int i_blocksize(const struct inode *node)
+{
+       return (1 << node->i_blkbits);
+}
+
 static inline int inode_unhashed(struct inode *inode)
 {
        return hlist_unhashed(&inode->i_hash);

diff --git a/mm/truncate.c b/mm/truncate.c
index 76e35ad971025ce5eb3781543537d1bf3b947b8d..f4c8270f7b84b0c0a297f66bb5dc34ba4fca3d40 100644 (file)
--- a/mm/truncate.c
+++ b/mm/truncate.c
@@ -732,7 +732,7 @@ EXPORT_SYMBOL(truncate_setsize);
  */
 void pagecache_isize_extended(struct inode *inode, loff_t from, loff_t to)
 {
-       int bsize = 1 << inode->i_blkbits;
+       int bsize = i_blocksize(inode);
        loff_t rounded_from;
        struct page *page;
        pgoff_t index;