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

diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 1b38abdaa3ed..ab2b0930054e 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -826,11 +826,11 @@ static bool parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
          * We cannot support mft record sizes above the PAGE_CACHE_SIZE since
          * we store $MFT/$DATA, the table of mft records in the page cache.
          */
-        if (vol->mft_record_size > PAGE_CACHE_SIZE) {
+        if (vol->mft_record_size > PAGE_SIZE) {
                 ntfs_error(vol->sb, "Mft record size (%i) exceeds the "
                                 "PAGE_CACHE_SIZE on your system (%lu).  "
                                 "This is not supported.  Sorry.",
-                                vol->mft_record_size, PAGE_CACHE_SIZE);
+                                vol->mft_record_size, PAGE_SIZE);
                 return false;
         }
         /* We cannot support mft record sizes below the sector size. */
@@ -1096,7 +1096,7 @@ static bool check_mft_mirror(ntfs_volume *vol)
 
         ntfs_debug("Entering.");
         /* Compare contents of $MFT and $MFTMirr. */
-        mrecs_per_page = PAGE_CACHE_SIZE / vol->mft_record_size;
+        mrecs_per_page = PAGE_SIZE / vol->mft_record_size;
         BUG_ON(!mrecs_per_page);
         BUG_ON(!vol->mftmirr_size);
         mft_page = mirr_page = NULL;
@@ -1615,20 +1615,20 @@ static bool load_and_init_attrdef(ntfs_volume *vol)
         if (!vol->attrdef)
                 goto iput_failed;
         index = 0;
-        max_index = i_size >> PAGE_CACHE_SHIFT;
-        size = PAGE_CACHE_SIZE;
+        max_index = i_size >> PAGE_SHIFT;
+        size = PAGE_SIZE;
         while (index < max_index) {
                 /* Read the attrdef table and copy it into the linear buffer. */
 read_partial_attrdef_page:
                 page = ntfs_map_page(ino->i_mapping, index);
                 if (IS_ERR(page))
                         goto free_iput_failed;
-                memcpy((u8*)vol->attrdef + (index++ << PAGE_CACHE_SHIFT),
+                memcpy((u8*)vol->attrdef + (index++ << PAGE_SHIFT),
                                 page_address(page), size);
                 ntfs_unmap_page(page);
         };
-        if (size == PAGE_CACHE_SIZE) {
-                size = i_size & ~PAGE_CACHE_MASK;
+        if (size == PAGE_SIZE) {
+                size = i_size & ~PAGE_MASK;
                 if (size)
                         goto read_partial_attrdef_page;
         }
@@ -1684,20 +1684,20 @@ static bool load_and_init_upcase(ntfs_volume *vol)
         if (!vol->upcase)
                 goto iput_upcase_failed;
         index = 0;
-        max_index = i_size >> PAGE_CACHE_SHIFT;
-        size = PAGE_CACHE_SIZE;
+        max_index = i_size >> PAGE_SHIFT;
+        size = PAGE_SIZE;
         while (index < max_index) {
                 /* Read the upcase table and copy it into the linear buffer. */
 read_partial_upcase_page:
                 page = ntfs_map_page(ino->i_mapping, index);
                 if (IS_ERR(page))
                         goto iput_upcase_failed;
-                memcpy((char*)vol->upcase + (index++ << PAGE_CACHE_SHIFT),
+                memcpy((char*)vol->upcase + (index++ << PAGE_SHIFT),
                                 page_address(page), size);
                 ntfs_unmap_page(page);
         };
-        if (size == PAGE_CACHE_SIZE) {
-                size = i_size & ~PAGE_CACHE_MASK;
+        if (size == PAGE_SIZE) {
+                size = i_size & ~PAGE_MASK;
                 if (size)
                         goto read_partial_upcase_page;
         }
@@ -2474,11 +2474,11 @@ static s64 get_nr_free_clusters(ntfs_volume *vol)
          * multiples of PAGE_CACHE_SIZE, rounding up so that if we have one
          * full and one partial page max_index = 2.
          */
-        max_index = (((vol->nr_clusters + 7) >> 3) + PAGE_CACHE_SIZE - 1) >>
-                        PAGE_CACHE_SHIFT;
+        max_index = (((vol->nr_clusters + 7) >> 3) + PAGE_SIZE - 1) >>
+                        PAGE_SHIFT;
         /* Use multiples of 4 bytes, thus max_size is PAGE_CACHE_SIZE / 4. */
         ntfs_debug("Reading $Bitmap, max_index = 0x%lx, max_size = 0x%lx.",
-                        max_index, PAGE_CACHE_SIZE / 4);
+                        max_index, PAGE_SIZE / 4);
         for (index = 0; index < max_index; index++) {
                 unsigned long *kaddr;
 
@@ -2491,7 +2491,7 @@ static s64 get_nr_free_clusters(ntfs_volume *vol)
                 if (IS_ERR(page)) {
                         ntfs_debug("read_mapping_page() error. Skipping "
                                         "page (index 0x%lx).", index);
-                        nr_free -= PAGE_CACHE_SIZE * 8;
+                        nr_free -= PAGE_SIZE * 8;
                         continue;
                 }
                 kaddr = kmap_atomic(page);
@@ -2503,9 +2503,9 @@ static s64 get_nr_free_clusters(ntfs_volume *vol)
                  * ntfs_readpage().
                  */
                 nr_free -= bitmap_weight(kaddr,
-                                        PAGE_CACHE_SIZE * BITS_PER_BYTE);
+                                        PAGE_SIZE * BITS_PER_BYTE);
                 kunmap_atomic(kaddr);
-                page_cache_release(page);
+                put_page(page);
         }
         ntfs_debug("Finished reading $Bitmap, last index = 0x%lx.", index - 1);
         /*
@@ -2549,7 +2549,7 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
         ntfs_debug("Entering.");
         /* Use multiples of 4 bytes, thus max_size is PAGE_CACHE_SIZE / 4. */
         ntfs_debug("Reading $MFT/$BITMAP, max_index = 0x%lx, max_size = "
-                        "0x%lx.", max_index, PAGE_CACHE_SIZE / 4);
+                        "0x%lx.", max_index, PAGE_SIZE / 4);
         for (index = 0; index < max_index; index++) {
                 unsigned long *kaddr;
 
@@ -2562,7 +2562,7 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
                 if (IS_ERR(page)) {
                         ntfs_debug("read_mapping_page() error. Skipping "
                                         "page (index 0x%lx).", index);
-                        nr_free -= PAGE_CACHE_SIZE * 8;
+                        nr_free -= PAGE_SIZE * 8;
                         continue;
                 }
                 kaddr = kmap_atomic(page);
@@ -2574,9 +2574,9 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
                  * ntfs_readpage().
                  */
                 nr_free -= bitmap_weight(kaddr,
-                                        PAGE_CACHE_SIZE * BITS_PER_BYTE);
+                                        PAGE_SIZE * BITS_PER_BYTE);
                 kunmap_atomic(kaddr);
-                page_cache_release(page);
+                put_page(page);
         }
         ntfs_debug("Finished reading $MFT/$BITMAP, last index = 0x%lx.",
                         index - 1);
@@ -2618,17 +2618,17 @@ static int ntfs_statfs(struct dentry *dentry, struct kstatfs *sfs)
         /* Type of filesystem. */
         sfs->f_type   = NTFS_SB_MAGIC;
         /* Optimal transfer block size. */
-        sfs->f_bsize  = PAGE_CACHE_SIZE;
+        sfs->f_bsize  = PAGE_SIZE;
         /*
          * Total data blocks in filesystem in units of f_bsize and since
          * inodes are also stored in data blocs ($MFT is a file) this is just
          * the total clusters.
          */
         sfs->f_blocks = vol->nr_clusters << vol->cluster_size_bits >>
-                                PAGE_CACHE_SHIFT;
+                                PAGE_SHIFT;
         /* Free data blocks in filesystem in units of f_bsize. */
         size          = get_nr_free_clusters(vol) << vol->cluster_size_bits >>
-                                PAGE_CACHE_SHIFT;
+                                PAGE_SHIFT;
         if (size < 0LL)
                 size = 0LL;
         /* Free blocks avail to non-superuser, same as above on NTFS. */
@@ -2643,7 +2643,7 @@ static int ntfs_statfs(struct dentry *dentry, struct kstatfs *sfs)
          * have one full and one partial page max_index = 2.
          */
         max_index = ((((mft_ni->initialized_size >> vol->mft_record_size_bits)
-                        + 7) >> 3) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+                        + 7) >> 3) + PAGE_SIZE - 1) >> PAGE_SHIFT;
         read_unlock_irqrestore(&mft_ni->size_lock, flags);
         /* Number of inodes in filesystem (at this point in time). */
         sfs->f_files = size;
@@ -2766,14 +2766,14 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
                 goto err_out_now;
 
         /* We support sector sizes up to the PAGE_CACHE_SIZE. */
-        if (bdev_logical_block_size(sb->s_bdev) > PAGE_CACHE_SIZE) {
+        if (bdev_logical_block_size(sb->s_bdev) > PAGE_SIZE) {
                 if (!silent)
                         ntfs_error(sb, "Device has unsupported sector size "
                                         "(%i).  The maximum supported sector "
                                         "size on this architecture is %lu "
                                         "bytes.",
                                         bdev_logical_block_size(sb->s_bdev),
-                                        PAGE_CACHE_SIZE);
+                                        PAGE_SIZE);
                 goto err_out_now;
         }
         /*