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, 22 insertions, 22 deletions

diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index ae9e5b308cf9..d5c2e9c865de 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -386,7 +386,7 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
                 goto finished;
         }
         /* read file tail into part of page */
-        offset = (cpu_key_k_offset(&key) - 1) & (PAGE_CACHE_SIZE - 1);
+        offset = (cpu_key_k_offset(&key) - 1) & (PAGE_SIZE - 1);
         copy_item_head(&tmp_ih, ih);
 
         /*
@@ -587,10 +587,10 @@ static int convert_tail_for_hole(struct inode *inode,
                 return -EIO;
 
         /* always try to read until the end of the block */
-        tail_start = tail_offset & (PAGE_CACHE_SIZE - 1);
+        tail_start = tail_offset & (PAGE_SIZE - 1);
         tail_end = (tail_start | (bh_result->b_size - 1)) + 1;
 
-        index = tail_offset >> PAGE_CACHE_SHIFT;
+        index = tail_offset >> PAGE_SHIFT;
         /*
          * hole_page can be zero in case of direct_io, we are sure
          * that we cannot get here if we write with O_DIRECT into tail page
@@ -629,7 +629,7 @@ static int convert_tail_for_hole(struct inode *inode,
 unlock:
         if (tail_page != hole_page) {
                 unlock_page(tail_page);
-                page_cache_release(tail_page);
+                put_page(tail_page);
         }
 out:
         return retval;
@@ -2189,11 +2189,11 @@ static int grab_tail_page(struct inode *inode,
          * we want the page with the last byte in the file,
          * not the page that will hold the next byte for appending
          */
-        unsigned long index = (inode->i_size - 1) >> PAGE_CACHE_SHIFT;
+        unsigned long index = (inode->i_size - 1) >> PAGE_SHIFT;
         unsigned long pos = 0;
         unsigned long start = 0;
         unsigned long blocksize = inode->i_sb->s_blocksize;
-        unsigned long offset = (inode->i_size) & (PAGE_CACHE_SIZE - 1);
+        unsigned long offset = (inode->i_size) & (PAGE_SIZE - 1);
         struct buffer_head *bh;
         struct buffer_head *head;
         struct page *page;
@@ -2251,7 +2251,7 @@ out:
 
 unlock:
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
         return error;
 }
 
@@ -2265,7 +2265,7 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
 {
         struct reiserfs_transaction_handle th;
         /* we want the offset for the first byte after the end of the file */
-        unsigned long offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
+        unsigned long offset = inode->i_size & (PAGE_SIZE - 1);
         unsigned blocksize = inode->i_sb->s_blocksize;
         unsigned length;
         struct page *page = NULL;
@@ -2345,7 +2345,7 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
                         }
                 }
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
         }
 
         reiserfs_write_unlock(inode->i_sb);
@@ -2354,7 +2354,7 @@ int reiserfs_truncate_file(struct inode *inode, int update_timestamps)
 out:
         if (page) {
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
         }
 
         reiserfs_write_unlock(inode->i_sb);
@@ -2426,7 +2426,7 @@ research:
         } else if (is_direct_le_ih(ih)) {
                 char *p;
                 p = page_address(bh_result->b_page);
-                p += (byte_offset - 1) & (PAGE_CACHE_SIZE - 1);
+                p += (byte_offset - 1) & (PAGE_SIZE - 1);
                 copy_size = ih_item_len(ih) - pos_in_item;
 
                 fs_gen = get_generation(inode->i_sb);
@@ -2525,7 +2525,7 @@ static int reiserfs_write_full_page(struct page *page,
                                     struct writeback_control *wbc)
 {
         struct inode *inode = page->mapping->host;
-        unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
+        unsigned long end_index = inode->i_size >> PAGE_SHIFT;
         int error = 0;
         unsigned long block;
         sector_t last_block;
@@ -2535,7 +2535,7 @@ static int reiserfs_write_full_page(struct page *page,
         int checked = PageChecked(page);
         struct reiserfs_transaction_handle th;
         struct super_block *s = inode->i_sb;
-        int bh_per_page = PAGE_CACHE_SIZE / s->s_blocksize;
+        int bh_per_page = PAGE_SIZE / s->s_blocksize;
         th.t_trans_id = 0;
 
         /* no logging allowed when nonblocking or from PF_MEMALLOC */
@@ -2564,16 +2564,16 @@ static int reiserfs_write_full_page(struct page *page,
         if (page->index >= end_index) {
                 unsigned last_offset;
 
-                last_offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
+                last_offset = inode->i_size & (PAGE_SIZE - 1);
                 /* no file contents in this page */
                 if (page->index >= end_index + 1 || !last_offset) {
                         unlock_page(page);
                         return 0;
                 }
-                zero_user_segment(page, last_offset, PAGE_CACHE_SIZE);
+                zero_user_segment(page, last_offset, PAGE_SIZE);
         }
         bh = head;
-        block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
+        block = page->index << (PAGE_SHIFT - s->s_blocksize_bits);
         last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
         /* first map all the buffers, logging any direct items we find */
         do {
@@ -2774,7 +2774,7 @@ static int reiserfs_write_begin(struct file *file,
                 *fsdata = (void *)(unsigned long)flags;
         }
 
-        index = pos >> PAGE_CACHE_SHIFT;
+        index = pos >> PAGE_SHIFT;
         page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
@@ -2822,7 +2822,7 @@ static int reiserfs_write_begin(struct file *file,
         }
         if (ret) {
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
                 /* Truncate allocated blocks */
                 reiserfs_truncate_failed_write(inode);
         }
@@ -2909,7 +2909,7 @@ static int reiserfs_write_end(struct file *file, struct address_space *mapping,
         else
                 th = NULL;
 
-        start = pos & (PAGE_CACHE_SIZE - 1);
+        start = pos & (PAGE_SIZE - 1);
         if (unlikely(copied < len)) {
                 if (!PageUptodate(page))
                         copied = 0;
@@ -2974,7 +2974,7 @@ out:
         if (locked)
                 reiserfs_write_unlock(inode->i_sb);
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 
         if (pos + len > inode->i_size)
                 reiserfs_truncate_failed_write(inode);
@@ -2996,7 +2996,7 @@ int reiserfs_commit_write(struct file *f, struct page *page,
                           unsigned from, unsigned to)
 {
         struct inode *inode = page->mapping->host;
-        loff_t pos = ((loff_t) page->index << PAGE_CACHE_SHIFT) + to;
+        loff_t pos = ((loff_t) page->index << PAGE_SHIFT) + to;
         int ret = 0;
         int update_sd = 0;
         struct reiserfs_transaction_handle *th = NULL;
@@ -3181,7 +3181,7 @@ static void reiserfs_invalidatepage(struct page *page, unsigned int offset,
         struct inode *inode = page->mapping->host;
         unsigned int curr_off = 0;
         unsigned int stop = offset + length;
-        int partial_page = (offset || length < PAGE_CACHE_SIZE);
+        int partial_page = (offset || length < PAGE_SIZE);
         int ret = 1;
 
         BUG_ON(!PageLocked(page));