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

PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.

This promise never materialized.  And unlikely will.

We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE.  And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.

Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.

Let's stop pretending that pages in page cache are special.  They are
not.

The changes are pretty straight-forward:

 - <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;

 - <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;

 - PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};

 - page_cache_get() -> get_page();

 - page_cache_release() -> put_page();

This patch contains automated changes generated with coccinelle using
script below.  For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.

The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.

There are few places in the code where coccinelle didn't reach.  I'll
fix them manually in a separate patch.  Comments and documentation also
will be addressed with the separate patch.

virtual patch

@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E

@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E

@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT

@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE

@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK

@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)

@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)

@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)

Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 58 insertions, 58 deletions

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index dab84a2530ff..8a43c683eef9 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1057,7 +1057,7 @@ int do_journal_get_write_access(handle_t *handle,
 static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
                                   get_block_t *get_block)
 {
-        unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+        unsigned from = pos & (PAGE_SIZE - 1);
         unsigned to = from + len;
         struct inode *inode = page->mapping->host;
         unsigned block_start, block_end;
@@ -1069,15 +1069,15 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
         bool decrypt = false;
 
         BUG_ON(!PageLocked(page));
-        BUG_ON(from > PAGE_CACHE_SIZE);
-        BUG_ON(to > PAGE_CACHE_SIZE);
+        BUG_ON(from > PAGE_SIZE);
+        BUG_ON(to > PAGE_SIZE);
         BUG_ON(from > to);
 
         if (!page_has_buffers(page))
                 create_empty_buffers(page, blocksize, 0);
         head = page_buffers(page);
         bbits = ilog2(blocksize);
-        block = (sector_t)page->index << (PAGE_CACHE_SHIFT - bbits);
+        block = (sector_t)page->index << (PAGE_SHIFT - bbits);
 
         for (bh = head, block_start = 0; bh != head || !block_start;
             block++, block_start = block_end, bh = bh->b_this_page) {
@@ -1159,8 +1159,8 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
          * we allocate blocks but write fails for some reason
          */
         needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
-        index = pos >> PAGE_CACHE_SHIFT;
-        from = pos & (PAGE_CACHE_SIZE - 1);
+        index = pos >> PAGE_SHIFT;
+        from = pos & (PAGE_SIZE - 1);
         to = from + len;
 
         if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
@@ -1188,7 +1188,7 @@ retry_grab:
 retry_journal:
         handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
         if (IS_ERR(handle)) {
-                page_cache_release(page);
+                put_page(page);
                 return PTR_ERR(handle);
         }
 
@@ -1196,7 +1196,7 @@ retry_journal:
         if (page->mapping != mapping) {
                 /* The page got truncated from under us */
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
                 ext4_journal_stop(handle);
                 goto retry_grab;
         }
@@ -1252,7 +1252,7 @@ retry_journal:
                 if (ret == -ENOSPC &&
                     ext4_should_retry_alloc(inode->i_sb, &retries))
                         goto retry_journal;
-                page_cache_release(page);
+                put_page(page);
                 return ret;
         }
         *pagep = page;
@@ -1295,7 +1295,7 @@ static int ext4_write_end(struct file *file,
                 ret = ext4_jbd2_file_inode(handle, inode);
                 if (ret) {
                         unlock_page(page);
-                        page_cache_release(page);
+                        put_page(page);
                         goto errout;
                 }
         }
@@ -1315,7 +1315,7 @@ static int ext4_write_end(struct file *file,
          */
         i_size_changed = ext4_update_inode_size(inode, pos + copied);
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 
         if (old_size < pos)
                 pagecache_isize_extended(inode, old_size, pos);
@@ -1399,7 +1399,7 @@ static int ext4_journalled_write_end(struct file *file,
         int size_changed = 0;
 
         trace_ext4_journalled_write_end(inode, pos, len, copied);
-        from = pos & (PAGE_CACHE_SIZE - 1);
+        from = pos & (PAGE_SIZE - 1);
         to = from + len;
 
         BUG_ON(!ext4_handle_valid(handle));
@@ -1423,7 +1423,7 @@ static int ext4_journalled_write_end(struct file *file,
         ext4_set_inode_state(inode, EXT4_STATE_JDATA);
         EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 
         if (old_size < pos)
                 pagecache_isize_extended(inode, old_size, pos);
@@ -1537,7 +1537,7 @@ static void ext4_da_page_release_reservation(struct page *page,
         int num_clusters;
         ext4_fsblk_t lblk;
 
-        BUG_ON(stop > PAGE_CACHE_SIZE || stop < length);
+        BUG_ON(stop > PAGE_SIZE || stop < length);
 
         head = page_buffers(page);
         bh = head;
@@ -1553,7 +1553,7 @@ static void ext4_da_page_release_reservation(struct page *page,
                         clear_buffer_delay(bh);
                 } else if (contiguous_blks) {
                         lblk = page->index <<
-                               (PAGE_CACHE_SHIFT - inode->i_blkbits);
+                               (PAGE_SHIFT - inode->i_blkbits);
                         lblk += (curr_off >> inode->i_blkbits) -
                                 contiguous_blks;
                         ext4_es_remove_extent(inode, lblk, contiguous_blks);
@@ -1563,7 +1563,7 @@ static void ext4_da_page_release_reservation(struct page *page,
         } while ((bh = bh->b_this_page) != head);
 
         if (contiguous_blks) {
-                lblk = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+                lblk = page->index << (PAGE_SHIFT - inode->i_blkbits);
                 lblk += (curr_off >> inode->i_blkbits) - contiguous_blks;
                 ext4_es_remove_extent(inode, lblk, contiguous_blks);
         }
@@ -1572,7 +1572,7 @@ static void ext4_da_page_release_reservation(struct page *page,
          * need to release the reserved space for that cluster. */
         num_clusters = EXT4_NUM_B2C(sbi, to_release);
         while (num_clusters > 0) {
-                lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) +
+                lblk = (page->index << (PAGE_SHIFT - inode->i_blkbits)) +
                         ((num_clusters - 1) << sbi->s_cluster_bits);
                 if (sbi->s_cluster_ratio == 1 ||
                     !ext4_find_delalloc_cluster(inode, lblk))
@@ -1619,8 +1619,8 @@ static void mpage_release_unused_pages(struct mpage_da_data *mpd,
         end   = mpd->next_page - 1;
         if (invalidate) {
                 ext4_lblk_t start, last;
-                start = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
-                last = end << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+                start = index << (PAGE_SHIFT - inode->i_blkbits);
+                last = end << (PAGE_SHIFT - inode->i_blkbits);
                 ext4_es_remove_extent(inode, start, last - start + 1);
         }
 
@@ -1636,7 +1636,7 @@ static void mpage_release_unused_pages(struct mpage_da_data *mpd,
                         BUG_ON(!PageLocked(page));
                         BUG_ON(PageWriteback(page));
                         if (invalidate) {
-                                block_invalidatepage(page, 0, PAGE_CACHE_SIZE);
+                                block_invalidatepage(page, 0, PAGE_SIZE);
                                 ClearPageUptodate(page);
                         }
                         unlock_page(page);
@@ -2007,10 +2007,10 @@ static int ext4_writepage(struct page *page,
 
         trace_ext4_writepage(page);
         size = i_size_read(inode);
-        if (page->index == size >> PAGE_CACHE_SHIFT)
-                len = size & ~PAGE_CACHE_MASK;
+        if (page->index == size >> PAGE_SHIFT)
+                len = size & ~PAGE_MASK;
         else
-                len = PAGE_CACHE_SIZE;
+                len = PAGE_SIZE;
 
         page_bufs = page_buffers(page);
         /*
@@ -2034,7 +2034,7 @@ static int ext4_writepage(struct page *page,
                                    ext4_bh_delay_or_unwritten)) {
                 redirty_page_for_writepage(wbc, page);
                 if ((current->flags & PF_MEMALLOC) ||
-                    (inode->i_sb->s_blocksize == PAGE_CACHE_SIZE)) {
+                    (inode->i_sb->s_blocksize == PAGE_SIZE)) {
                         /*
                          * For memory cleaning there's no point in writing only
                          * some buffers. So just bail out. Warn if we came here
@@ -2076,10 +2076,10 @@ static int mpage_submit_page(struct mpage_da_data *mpd, struct page *page)
         int err;
 
         BUG_ON(page->index != mpd->first_page);
-        if (page->index == size >> PAGE_CACHE_SHIFT)
-                len = size & ~PAGE_CACHE_MASK;
+        if (page->index == size >> PAGE_SHIFT)
+                len = size & ~PAGE_MASK;
         else
-                len = PAGE_CACHE_SIZE;
+                len = PAGE_SIZE;
         clear_page_dirty_for_io(page);
         err = ext4_bio_write_page(&mpd->io_submit, page, len, mpd->wbc, false);
         if (!err)
@@ -2213,7 +2213,7 @@ static int mpage_map_and_submit_buffers(struct mpage_da_data *mpd)
         int nr_pages, i;
         struct inode *inode = mpd->inode;
         struct buffer_head *head, *bh;
-        int bpp_bits = PAGE_CACHE_SHIFT - inode->i_blkbits;
+        int bpp_bits = PAGE_SHIFT - inode->i_blkbits;
         pgoff_t start, end;
         ext4_lblk_t lblk;
         sector_t pblock;
@@ -2274,7 +2274,7 @@ static int mpage_map_and_submit_buffers(struct mpage_da_data *mpd)
                          * supports blocksize < pagesize as we will try to
                          * convert potentially unmapped parts of inode.
                          */
-                        mpd->io_submit.io_end->size += PAGE_CACHE_SIZE;
+                        mpd->io_submit.io_end->size += PAGE_SIZE;
                         /* Page fully mapped - let IO run! */
                         err = mpage_submit_page(mpd, page);
                         if (err < 0) {
@@ -2426,7 +2426,7 @@ update_disksize:
          * Update on-disk size after IO is submitted.  Races with
          * truncate are avoided by checking i_size under i_data_sem.
          */
-        disksize = ((loff_t)mpd->first_page) << PAGE_CACHE_SHIFT;
+        disksize = ((loff_t)mpd->first_page) << PAGE_SHIFT;
         if (disksize > EXT4_I(inode)->i_disksize) {
                 int err2;
                 loff_t i_size;
@@ -2562,7 +2562,7 @@ static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
                         mpd->next_page = page->index + 1;
                         /* Add all dirty buffers to mpd */
                         lblk = ((ext4_lblk_t)page->index) <<
-                                (PAGE_CACHE_SHIFT - blkbits);
+                                (PAGE_SHIFT - blkbits);
                         head = page_buffers(page);
                         err = mpage_process_page_bufs(mpd, head, head, lblk);
                         if (err <= 0)
@@ -2647,7 +2647,7 @@ static int ext4_writepages(struct address_space *mapping,
                  * We may need to convert up to one extent per block in
                  * the page and we may dirty the inode.
                  */
-                rsv_blocks = 1 + (PAGE_CACHE_SIZE >> inode->i_blkbits);
+                rsv_blocks = 1 + (PAGE_SIZE >> inode->i_blkbits);
         }
 
         /*
@@ -2678,8 +2678,8 @@ static int ext4_writepages(struct address_space *mapping,
                 mpd.first_page = writeback_index;
                 mpd.last_page = -1;
         } else {
-                mpd.first_page = wbc->range_start >> PAGE_CACHE_SHIFT;
-                mpd.last_page = wbc->range_end >> PAGE_CACHE_SHIFT;
+                mpd.first_page = wbc->range_start >> PAGE_SHIFT;
+                mpd.last_page = wbc->range_end >> PAGE_SHIFT;
         }
 
         mpd.inode = inode;
@@ -2838,7 +2838,7 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
         struct inode *inode = mapping->host;
         handle_t *handle;
 
-        index = pos >> PAGE_CACHE_SHIFT;
+        index = pos >> PAGE_SHIFT;
 
         if (ext4_nonda_switch(inode->i_sb)) {
                 *fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
@@ -2881,7 +2881,7 @@ retry_journal:
         handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
                                 ext4_da_write_credits(inode, pos, len));
         if (IS_ERR(handle)) {
-                page_cache_release(page);
+                put_page(page);
                 return PTR_ERR(handle);
         }
 
@@ -2889,7 +2889,7 @@ retry_journal:
         if (page->mapping != mapping) {
                 /* The page got truncated from under us */
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
                 ext4_journal_stop(handle);
                 goto retry_grab;
         }
@@ -2917,7 +2917,7 @@ retry_journal:
                     ext4_should_retry_alloc(inode->i_sb, &retries))
                         goto retry_journal;
 
-                page_cache_release(page);
+                put_page(page);
                 return ret;
         }
 
@@ -2965,7 +2965,7 @@ static int ext4_da_write_end(struct file *file,
                                       len, copied, page, fsdata);
 
         trace_ext4_da_write_end(inode, pos, len, copied);
-        start = pos & (PAGE_CACHE_SIZE - 1);
+        start = pos & (PAGE_SIZE - 1);
         end = start + copied - 1;
 
         /*
@@ -3187,7 +3187,7 @@ static int __ext4_journalled_invalidatepage(struct page *page,
         /*
          * If it's a full truncate we just forget about the pending dirtying
          */
-        if (offset == 0 && length == PAGE_CACHE_SIZE)
+        if (offset == 0 && length == PAGE_SIZE)
                 ClearPageChecked(page);
 
         return jbd2_journal_invalidatepage(journal, page, offset, length);
@@ -3556,8 +3556,8 @@ void ext4_set_aops(struct inode *inode)
 static int __ext4_block_zero_page_range(handle_t *handle,
                 struct address_space *mapping, loff_t from, loff_t length)
 {
-        ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
-        unsigned offset = from & (PAGE_CACHE_SIZE-1);
+        ext4_fsblk_t index = from >> PAGE_SHIFT;
+        unsigned offset = from & (PAGE_SIZE-1);
         unsigned blocksize, pos;
         ext4_lblk_t iblock;
         struct inode *inode = mapping->host;
@@ -3565,14 +3565,14 @@ static int __ext4_block_zero_page_range(handle_t *handle,
         struct page *page;
         int err = 0;
 
-        page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT,
+        page = find_or_create_page(mapping, from >> PAGE_SHIFT,
                                    mapping_gfp_constraint(mapping, ~__GFP_FS));
         if (!page)
                 return -ENOMEM;
 
         blocksize = inode->i_sb->s_blocksize;
 
-        iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
+        iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
 
         if (!page_has_buffers(page))
                 create_empty_buffers(page, blocksize, 0);
@@ -3614,7 +3614,7 @@ static int __ext4_block_zero_page_range(handle_t *handle,
                     ext4_encrypted_inode(inode)) {
                         /* We expect the key to be set. */
                         BUG_ON(!ext4_has_encryption_key(inode));
-                        BUG_ON(blocksize != PAGE_CACHE_SIZE);
+                        BUG_ON(blocksize != PAGE_SIZE);
                         WARN_ON_ONCE(ext4_decrypt(page));
                 }
         }
@@ -3638,7 +3638,7 @@ static int __ext4_block_zero_page_range(handle_t *handle,
 
 unlock:
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
         return err;
 }
 
@@ -3653,7 +3653,7 @@ static int ext4_block_zero_page_range(handle_t *handle,
                 struct address_space *mapping, loff_t from, loff_t length)
 {
         struct inode *inode = mapping->host;
-        unsigned offset = from & (PAGE_CACHE_SIZE-1);
+        unsigned offset = from & (PAGE_SIZE-1);
         unsigned blocksize = inode->i_sb->s_blocksize;
         unsigned max = blocksize - (offset & (blocksize - 1));
 
@@ -3678,7 +3678,7 @@ static int ext4_block_zero_page_range(handle_t *handle,
 static int ext4_block_truncate_page(handle_t *handle,
                 struct address_space *mapping, loff_t from)
 {
-        unsigned offset = from & (PAGE_CACHE_SIZE-1);
+        unsigned offset = from & (PAGE_SIZE-1);
         unsigned length;
         unsigned blocksize;
         struct inode *inode = mapping->host;
@@ -3816,7 +3816,7 @@ int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length)
          */
         if (offset + length > inode->i_size) {
                 length = inode->i_size +
-                   PAGE_CACHE_SIZE - (inode->i_size & (PAGE_CACHE_SIZE - 1)) -
+                   PAGE_SIZE - (inode->i_size & (PAGE_SIZE - 1)) -
                    offset;
         }
 
@@ -4891,23 +4891,23 @@ static void ext4_wait_for_tail_page_commit(struct inode *inode)
         tid_t commit_tid = 0;
         int ret;
 
-        offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
+        offset = inode->i_size & (PAGE_SIZE - 1);
         /*
          * All buffers in the last page remain valid? Then there's nothing to
          * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
          * blocksize case
          */
-        if (offset > PAGE_CACHE_SIZE - (1 << inode->i_blkbits))
+        if (offset > PAGE_SIZE - (1 << inode->i_blkbits))
                 return;
         while (1) {
                 page = find_lock_page(inode->i_mapping,
-                                      inode->i_size >> PAGE_CACHE_SHIFT);
+                                      inode->i_size >> PAGE_SHIFT);
                 if (!page)
                         return;
                 ret = __ext4_journalled_invalidatepage(page, offset,
-                                                PAGE_CACHE_SIZE - offset);
+                                                PAGE_SIZE - offset);
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
                 if (ret != -EBUSY)
                         return;
                 commit_tid = 0;
@@ -5546,10 +5546,10 @@ int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
                 goto out;
         }
 
-        if (page->index == size >> PAGE_CACHE_SHIFT)
-                len = size & ~PAGE_CACHE_MASK;
+        if (page->index == size >> PAGE_SHIFT)
+                len = size & ~PAGE_MASK;
         else
-                len = PAGE_CACHE_SIZE;
+                len = PAGE_SIZE;
         /*
          * Return if we have all the buffers mapped. This avoids the need to do
          * journal_start/journal_stop which can block and take a long time
@@ -5580,7 +5580,7 @@ retry_alloc:
         ret = block_page_mkwrite(vma, vmf, get_block);
         if (!ret && ext4_should_journal_data(inode)) {
                 if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
-                          PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) {
+                          PAGE_SIZE, NULL, do_journal_get_write_access)) {
                         unlock_page(page);
                         ret = VM_FAULT_SIGBUS;
                         ext4_journal_stop(handle);