mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros

[mirror_ubuntu-zesty-kernel.git] / fs / f2fs / file.c

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index b41c3579ea9e859bd692127e30c1b998e4346fb9..443e07705c2a6099f6491eb8701d0654de3029f7 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -74,11 +74,11 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
                goto mapped;
 
        /* page is wholly or partially inside EOF */
-       if (((loff_t)(page->index + 1) << PAGE_CACHE_SHIFT) >
+       if (((loff_t)(page->index + 1) << PAGE_SHIFT) >
                                                i_size_read(inode)) {
                unsigned offset;
-               offset = i_size_read(inode) & ~PAGE_CACHE_MASK;
-               zero_user_segment(page, offset, PAGE_CACHE_SIZE);
+               offset = i_size_read(inode) & ~PAGE_MASK;
+               zero_user_segment(page, offset, PAGE_SIZE);
        }
        set_page_dirty(page);
        SetPageUptodate(page);
@@ -346,11 +346,11 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
                goto found;
        }
 
-       pgofs = (pgoff_t)(offset >> PAGE_CACHE_SHIFT);
+       pgofs = (pgoff_t)(offset >> PAGE_SHIFT);
 
        dirty = __get_first_dirty_index(inode->i_mapping, pgofs, whence);
 
-       for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_CACHE_SHIFT) {
+       for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
                set_new_dnode(&dn, inode, NULL, NULL, 0);
                err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE_RA);
                if (err && err != -ENOENT) {
@@ -370,7 +370,7 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
                /* find data/hole in dnode block */
                for (; dn.ofs_in_node < end_offset;
                                dn.ofs_in_node++, pgofs++,
-                               data_ofs = (loff_t)pgofs << PAGE_CACHE_SHIFT) {
+                               data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
                        block_t blkaddr;
                        blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
 
@@ -508,8 +508,8 @@ void truncate_data_blocks(struct dnode_of_data *dn)
 static int truncate_partial_data_page(struct inode *inode, u64 from,
                                                                bool cache_only)
 {
-       unsigned offset = from & (PAGE_CACHE_SIZE - 1);
-       pgoff_t index = from >> PAGE_CACHE_SHIFT;
+       unsigned offset = from & (PAGE_SIZE - 1);
+       pgoff_t index = from >> PAGE_SHIFT;
        struct address_space *mapping = inode->i_mapping;
        struct page *page;
 
@@ -529,7 +529,7 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
                return 0;
 truncate_out:
        f2fs_wait_on_page_writeback(page, DATA, true);
-       zero_user(page, offset, PAGE_CACHE_SIZE - offset);
+       zero_user(page, offset, PAGE_SIZE - offset);
        if (!cache_only || !f2fs_encrypted_inode(inode) ||
                                        !S_ISREG(inode->i_mode))
                set_page_dirty(page);
@@ -799,11 +799,11 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
        if (ret)
                return ret;
 
-       pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
-       pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
+       pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
+       pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
 
-       off_start = offset & (PAGE_CACHE_SIZE - 1);
-       off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
+       off_start = offset & (PAGE_SIZE - 1);
+       off_end = (offset + len) & (PAGE_SIZE - 1);
 
        if (pg_start == pg_end) {
                ret = fill_zero(inode, pg_start, off_start,
@@ -813,7 +813,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
        } else {
                if (off_start) {
                        ret = fill_zero(inode, pg_start++, off_start,
-                                               PAGE_CACHE_SIZE - off_start);
+                                               PAGE_SIZE - off_start);
                        if (ret)
                                return ret;
                }
@@ -830,8 +830,8 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
 
                        f2fs_balance_fs(sbi, true);
 
-                       blk_start = (loff_t)pg_start << PAGE_CACHE_SHIFT;
-                       blk_end = (loff_t)pg_end << PAGE_CACHE_SHIFT;
+                       blk_start = (loff_t)pg_start << PAGE_SHIFT;
+                       blk_end = (loff_t)pg_end << PAGE_SHIFT;
                        truncate_inode_pages_range(mapping, blk_start,
                                        blk_end - 1);
 
@@ -954,8 +954,8 @@ static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
        if (ret)
                return ret;
 
-       pg_start = offset >> PAGE_CACHE_SHIFT;
-       pg_end = (offset + len) >> PAGE_CACHE_SHIFT;
+       pg_start = offset >> PAGE_SHIFT;
+       pg_end = (offset + len) >> PAGE_SHIFT;
 
        /* write out all dirty pages from offset */
        ret = filemap_write_and_wait_range(inode->i_mapping, offset, LLONG_MAX);
@@ -1006,11 +1006,11 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
 
        truncate_pagecache_range(inode, offset, offset + len - 1);
 
-       pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
-       pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
+       pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
+       pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
 
-       off_start = offset & (PAGE_CACHE_SIZE - 1);
-       off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
+       off_start = offset & (PAGE_SIZE - 1);
+       off_end = (offset + len) & (PAGE_SIZE - 1);
 
        if (pg_start == pg_end) {
                ret = fill_zero(inode, pg_start, off_start,
@@ -1024,12 +1024,12 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
        } else {
                if (off_start) {
                        ret = fill_zero(inode, pg_start++, off_start,
-                                               PAGE_CACHE_SIZE - off_start);
+                                               PAGE_SIZE - off_start);
                        if (ret)
                                return ret;
 
                        new_size = max_t(loff_t, new_size,
-                                       (loff_t)pg_start << PAGE_CACHE_SHIFT);
+                                       (loff_t)pg_start << PAGE_SHIFT);
                }
 
                for (index = pg_start; index < pg_end; index++) {
@@ -1060,7 +1060,7 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
                        f2fs_unlock_op(sbi);
 
                        new_size = max_t(loff_t, new_size,
-                               (loff_t)(index + 1) << PAGE_CACHE_SHIFT);
+                               (loff_t)(index + 1) << PAGE_SHIFT);
                }
 
                if (off_end) {
@@ -1117,8 +1117,8 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
 
        truncate_pagecache(inode, offset);
 
-       pg_start = offset >> PAGE_CACHE_SHIFT;
-       pg_end = (offset + len) >> PAGE_CACHE_SHIFT;
+       pg_start = offset >> PAGE_SHIFT;
+       pg_end = (offset + len) >> PAGE_SHIFT;
        delta = pg_end - pg_start;
        nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
 
@@ -1158,11 +1158,11 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
 
        f2fs_balance_fs(sbi, true);
 
-       pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
-       pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
+       pg_start = ((unsigned long long) offset) >> PAGE_SHIFT;
+       pg_end = ((unsigned long long) offset + len) >> PAGE_SHIFT;
 
-       off_start = offset & (PAGE_CACHE_SIZE - 1);
-       off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
+       off_start = offset & (PAGE_SIZE - 1);
+       off_end = (offset + len) & (PAGE_SIZE - 1);
 
        f2fs_lock_op(sbi);
 
@@ -1180,12 +1180,12 @@ noalloc:
                if (pg_start == pg_end)
                        new_size = offset + len;
                else if (index == pg_start && off_start)
-                       new_size = (loff_t)(index + 1) << PAGE_CACHE_SHIFT;
+                       new_size = (loff_t)(index + 1) << PAGE_SHIFT;
                else if (index == pg_end)
-                       new_size = ((loff_t)index << PAGE_CACHE_SHIFT) +
+                       new_size = ((loff_t)index << PAGE_SHIFT) +
                                                                off_end;
                else
-                       new_size += PAGE_CACHE_SIZE;
+                       new_size += PAGE_SIZE;
        }
 
        if (!(mode & FALLOC_FL_KEEP_SIZE) &&
@@ -1652,8 +1652,8 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
        if (need_inplace_update(inode))
                return -EINVAL;
 
-       pg_start = range->start >> PAGE_CACHE_SHIFT;
-       pg_end = (range->start + range->len) >> PAGE_CACHE_SHIFT;
+       pg_start = range->start >> PAGE_SHIFT;
+       pg_end = (range->start + range->len) >> PAGE_SHIFT;
 
        f2fs_balance_fs(sbi, true);
 
@@ -1770,7 +1770,7 @@ clear_out:
 out:
        inode_unlock(inode);
        if (!err)
-               range->len = (u64)total << PAGE_CACHE_SHIFT;
+               range->len = (u64)total << PAGE_SHIFT;
        return err;
 }