mm, fs: remove remaining PAGE_CACHE_* and page_cache_{get,release} usage

Mostly direct substitution with occasional adjustment or removing
outdated comments.

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>

34 files changed, 78 insertions, 89 deletions

diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 866789ede4cb..516e19d1d202 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -3039,13 +3039,13 @@ int btrfsic_mount(struct btrfs_root *root,
 
         if (root->nodesize & ((u64)PAGE_SIZE - 1)) {
                 printk(KERN_INFO
-                       "btrfsic: cannot handle nodesize %d not being a multiple of PAGE_CACHE_SIZE %ld!\n",
+                       "btrfsic: cannot handle nodesize %d not being a multiple of PAGE_SIZE %ld!\n",
                        root->nodesize, PAGE_SIZE);
                 return -1;
         }
         if (root->sectorsize & ((u64)PAGE_SIZE - 1)) {
                 printk(KERN_INFO
-                       "btrfsic: cannot handle sectorsize %d not being a multiple of PAGE_CACHE_SIZE %ld!\n",
+                       "btrfsic: cannot handle sectorsize %d not being a multiple of PAGE_SIZE %ld!\n",
                        root->sectorsize, PAGE_SIZE);
                 return -1;
         }
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 93d696d248d9..d247fc0eea19 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3264,13 +3264,11 @@ static noinline_for_stack int writepage_delalloc(struct inode *inode,
                         goto done;
                 }
                 /*
-                 * delalloc_end is already one less than the total
-                 * length, so we don't subtract one from
-                 * PAGE_CACHE_SIZE
+                 * delalloc_end is already one less than the total length, so
+                 * we don't subtract one from PAGE_SIZE
                  */
                 delalloc_to_write += (delalloc_end - delalloc_start +
-                                      PAGE_SIZE) >>
-                                      PAGE_SHIFT;
+                                      PAGE_SIZE) >> PAGE_SHIFT;
                 delalloc_start = delalloc_end + 1;
         }
         if (wbc->nr_to_write < delalloc_to_write) {
diff --git a/fs/btrfs/struct-funcs.c b/fs/btrfs/struct-funcs.c
index b976597b0721..e05619f241be 100644
--- a/fs/btrfs/struct-funcs.c
+++ b/fs/btrfs/struct-funcs.c
@@ -66,7 +66,7 @@ u##bits btrfs_get_token_##bits(struct extent_buffer *eb, void *ptr,	\
                                                                         \
         if (token && token->kaddr && token->offset <= offset &&         \
             token->eb == eb &&                                          \
-           (token->offset + PAGE_CACHE_SIZE >= offset + size)) {        \
+           (token->offset + PAGE_SIZE >= offset + size)) {      \
                 kaddr = token->kaddr;                                   \
                 p = kaddr + part_offset - token->offset;                \
                 res = get_unaligned_le##bits(p + off);                  \
@@ -104,7 +104,7 @@ void btrfs_set_token_##bits(struct extent_buffer *eb,			\
                                                                         \
         if (token && token->kaddr && token->offset <= offset &&         \
             token->eb == eb &&                                          \
-           (token->offset + PAGE_CACHE_SIZE >= offset + size)) {        \
+           (token->offset + PAGE_SIZE >= offset + size)) {      \
                 kaddr = token->kaddr;                                   \
                 p = kaddr + part_offset - token->offset;                \
                 put_unaligned_le##bits(val, p + off);                   \
diff --git a/fs/btrfs/tests/extent-io-tests.c b/fs/btrfs/tests/extent-io-tests.c
index ac3a06d28531..70948b13bc81 100644
--- a/fs/btrfs/tests/extent-io-tests.c
+++ b/fs/btrfs/tests/extent-io-tests.c
@@ -239,7 +239,7 @@ static int test_find_delalloc(void)
         end = 0;
         /*
          * Currently if we fail to find dirty pages in the delalloc range we
-         * will adjust max_bytes down to PAGE_CACHE_SIZE and then re-search.  If
+         * will adjust max_bytes down to PAGE_SIZE and then re-search.  If
          * this changes at any point in the future we will need to fix this
          * tests expected behavior.
          */
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index d21da9f05bae..f2cc0b3d1af7 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -714,7 +714,7 @@ compare_mid(__u16 mid, const struct smb_hdr *smb)
  *
  * Note that this might make for "interesting" allocation problems during
  * writeback however as we have to allocate an array of pointers for the
- * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
+ * pages. A 16M write means ~32kb page array with PAGE_SIZE == 4096.
  *
  * For reads, there is a similar problem as we need to allocate an array
  * of kvecs to handle the receive, though that should only need to be done
@@ -733,7 +733,7 @@ compare_mid(__u16 mid, const struct smb_hdr *smb)
 
 /*
  * The default wsize is 1M. find_get_pages seems to return a maximum of 256
- * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
+ * pages in a single call. With PAGE_SIZE == 4k, this means we can fill
  * a single wsize request with a single call.
  */
 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 5ce540dc6996..c03d0744648b 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1902,7 +1902,7 @@ wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
          * find_get_pages_tag seems to return a max of 256 on each
          * iteration, so we must call it several times in order to
          * fill the array or the wsize is effectively limited to
-         * 256 * PAGE_CACHE_SIZE.
+         * 256 * PAGE_SIZE.
          */
         *found_pages = 0;
         pages = wdata->pages;
diff --git a/fs/cramfs/README b/fs/cramfs/README
index 445d1c2d7646..9d4e7ea311f4 100644
--- a/fs/cramfs/README
+++ b/fs/cramfs/README
@@ -86,26 +86,26 @@ Block Size
 
 (Block size in cramfs refers to the size of input data that is
 compressed at a time.  It's intended to be somewhere around
-PAGE_CACHE_SIZE for cramfs_readpage's convenience.)
+PAGE_SIZE for cramfs_readpage's convenience.)
 
 The superblock ought to indicate the block size that the fs was
 written for, since comments in <linux/pagemap.h> indicate that
-PAGE_CACHE_SIZE may grow in future (if I interpret the comment
+PAGE_SIZE may grow in future (if I interpret the comment
 correctly).
 
-Currently, mkcramfs #define's PAGE_CACHE_SIZE as 4096 and uses that
-for blksize, whereas Linux-2.3.39 uses its PAGE_CACHE_SIZE, which in
+Currently, mkcramfs #define's PAGE_SIZE as 4096 and uses that
+for blksize, whereas Linux-2.3.39 uses its PAGE_SIZE, which in
 turn is defined as PAGE_SIZE (which can be as large as 32KB on arm).
 This discrepancy is a bug, though it's not clear which should be
 changed.
 
-One option is to change mkcramfs to take its PAGE_CACHE_SIZE from
+One option is to change mkcramfs to take its PAGE_SIZE from
 <asm/page.h>.  Personally I don't like this option, but it does
 require the least amount of change: just change `#define
-PAGE_CACHE_SIZE (4096)' to `#include <asm/page.h>'.  The disadvantage
+PAGE_SIZE (4096)' to `#include <asm/page.h>'.  The disadvantage
 is that the generated cramfs cannot always be shared between different
 kernels, not even necessarily kernels of the same architecture if
-PAGE_CACHE_SIZE is subject to change between kernel versions
+PAGE_SIZE is subject to change between kernel versions
 (currently possible with arm and ia64).
 
 The remaining options try to make cramfs more sharable.
@@ -126,22 +126,22 @@ size.  The options are:
   1. Always 4096 bytes.
 
   2. Writer chooses blocksize; kernel adapts but rejects blocksize >
-     PAGE_CACHE_SIZE.
+     PAGE_SIZE.
 
   3. Writer chooses blocksize; kernel adapts even to blocksize >
-     PAGE_CACHE_SIZE.
+     PAGE_SIZE.
 
 It's easy enough to change the kernel to use a smaller value than
-PAGE_CACHE_SIZE: just make cramfs_readpage read multiple blocks.
+PAGE_SIZE: just make cramfs_readpage read multiple blocks.
 
-The cost of option 1 is that kernels with a larger PAGE_CACHE_SIZE
+The cost of option 1 is that kernels with a larger PAGE_SIZE
 value don't get as good compression as they can.
 
 The cost of option 2 relative to option 1 is that the code uses
 variables instead of #define'd constants.  The gain is that people
-with kernels having larger PAGE_CACHE_SIZE can make use of that if
+with kernels having larger PAGE_SIZE can make use of that if
 they don't mind their cramfs being inaccessible to kernels with
-smaller PAGE_CACHE_SIZE values.
+smaller PAGE_SIZE values.
 
 Option 3 is easy to implement if we don't mind being CPU-inefficient:
 e.g. get readpage to decompress to a buffer of size MAX_BLKSIZE (which
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index 2096654dd26d..3a32ddf98095 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -137,7 +137,7 @@ static struct inode *get_cramfs_inode(struct super_block *sb,
  * page cache and dentry tree anyway..
  *
  * This also acts as a way to guarantee contiguous areas of up to
- * BLKS_PER_BUF*PAGE_CACHE_SIZE, so that the caller doesn't need to
+ * BLKS_PER_BUF*PAGE_SIZE, so that the caller doesn't need to
  * worry about end-of-buffer issues even when decompressing a full
  * page cache.
  */
diff --git a/fs/dax.c b/fs/dax.c
index 1f954166704a..75ba46d82a76 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -1094,7 +1094,7 @@ EXPORT_SYMBOL_GPL(dax_pfn_mkwrite);
  * you are truncating a file, the helper function dax_truncate_page() may be
  * more convenient.
  *
- * We work in terms of PAGE_CACHE_SIZE here for commonality with
+ * We work in terms of PAGE_SIZE here for commonality with
  * block_truncate_page(), but we could go down to PAGE_SIZE if the filesystem
  * took care of disposing of the unnecessary blocks.  Even if the filesystem
  * block size is smaller than PAGE_SIZE, we have to zero the rest of the page
@@ -1146,7 +1146,7 @@ EXPORT_SYMBOL_GPL(dax_zero_page_range);
  * Similar to block_truncate_page(), this function can be called by a
  * filesystem when it is truncating a DAX file to handle the partial page.
  *
- * We work in terms of PAGE_CACHE_SIZE here for commonality with
+ * We work in terms of PAGE_SIZE here for commonality with
  * block_truncate_page(), but we could go down to PAGE_SIZE if the filesystem
  * took care of disposing of the unnecessary blocks.  Even if the filesystem
  * block size is smaller than PAGE_SIZE, we have to zero the rest of the page
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 2a988f3a0cdb..224b49e71aa4 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -763,8 +763,8 @@ static int truncate_upper(struct dentry *dentry, struct iattr *ia,
         } else { /* ia->ia_size < i_size_read(inode) */
                 /* We're chopping off all the pages down to the page
                  * in which ia->ia_size is located. Fill in the end of
-                 * that page from (ia->ia_size & ~PAGE_CACHE_MASK) to
-                 * PAGE_CACHE_SIZE with zeros. */
+                 * that page from (ia->ia_size & ~PAGE_MASK) to
+                 * PAGE_SIZE with zeros. */
                 size_t num_zeros = (PAGE_SIZE
                                     - (ia->ia_size & ~PAGE_MASK));
 
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 1b45694de316..7ff6fcfa685d 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -37,7 +37,7 @@ static inline unsigned ext2_rec_len_from_disk(__le16 dlen)
 {
         unsigned len = le16_to_cpu(dlen);
 
-#if (PAGE_CACHE_SIZE >= 65536)
+#if (PAGE_SIZE >= 65536)
         if (len == EXT2_MAX_REC_LEN)
                 return 1 << 16;
 #endif
@@ -46,7 +46,7 @@ static inline unsigned ext2_rec_len_from_disk(__le16 dlen)
 
 static inline __le16 ext2_rec_len_to_disk(unsigned len)
 {
-#if (PAGE_CACHE_SIZE >= 65536)
+#if (PAGE_SIZE >= 65536)
         if (len == (1 << 16))
                 return cpu_to_le16(EXT2_MAX_REC_LEN);
         else
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index c04743519865..7ccba1aa142d 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1961,7 +1961,7 @@ ext4_rec_len_from_disk(__le16 dlen, unsigned blocksize)
 {
         unsigned len = le16_to_cpu(dlen);
 
-#if (PAGE_CACHE_SIZE >= 65536)
+#if (PAGE_SIZE >= 65536)
         if (len == EXT4_MAX_REC_LEN || len == 0)
                 return blocksize;
         return (len & 65532) | ((len & 3) << 16);
@@ -1974,7 +1974,7 @@ static inline __le16 ext4_rec_len_to_disk(unsigned len, unsigned blocksize)
 {
         if ((len > blocksize) || (blocksize > (1 << 18)) || (len & 3))
                 BUG();
-#if (PAGE_CACHE_SIZE >= 65536)
+#if (PAGE_SIZE >= 65536)
         if (len < 65536)
                 return cpu_to_le16(len);
         if (len == blocksize) {
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 8a43c683eef9..4f7043ba4447 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -4894,7 +4894,7 @@ static void ext4_wait_for_tail_page_commit(struct inode *inode)
         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 ==
+         * do. We do the check mainly to optimize the common PAGE_SIZE ==
          * blocksize case
          */
         if (offset > PAGE_SIZE - (1 << inode->i_blkbits))
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index c12174711ce2..eeeade76012e 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -119,7 +119,7 @@ MODULE_PARM_DESC(mballoc_debug, "Debugging level for ext4's mballoc");
  *
  *
  * one block each for bitmap and buddy information.  So for each group we
- * take up 2 blocks. A page can contain blocks_per_page (PAGE_CACHE_SIZE /
+ * take up 2 blocks. A page can contain blocks_per_page (PAGE_SIZE /
  * blocksize) blocks.  So it can have information regarding groups_per_page
  * which is blocks_per_page/2
  *
@@ -807,7 +807,7 @@ static void mb_regenerate_buddy(struct ext4_buddy *e4b)
  *
  * one block each for bitmap and buddy information.
  * So for each group we take up 2 blocks. A page can
- * contain blocks_per_page (PAGE_CACHE_SIZE / blocksize)  blocks.
+ * contain blocks_per_page (PAGE_SIZE / blocksize)  blocks.
  * So it can have information regarding groups_per_page which
  * is blocks_per_page/2
  *
diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index ea27aa1a778c..f24e7299e1c8 100644
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -23,7 +23,7 @@
  *
  * then this code just gives up and calls the buffer_head-based read function.
  * It does handle a page which has holes at the end - that is a common case:
- * the end-of-file on blocksize < PAGE_CACHE_SIZE setups.
+ * the end-of-file on blocksize < PAGE_SIZE setups.
  *
  */
 
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index afb7c7f05de5..4ea71eba40a5 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -237,7 +237,7 @@ hugetlbfs_read_actor(struct page *page, unsigned long offset,
 /*
  * Support for read() - Find the page attached to f_mapping and copy out the
  * data. Its *very* similar to do_generic_mapping_read(), we can't use that
- * since it has PAGE_CACHE_SIZE assumptions.
+ * since it has PAGE_SIZE assumptions.
  */
 static ssize_t hugetlbfs_read_iter(struct kiocb *iocb, struct iov_iter *to)
 {
diff --git a/fs/mpage.c b/fs/mpage.c
index e7083bfbabb3..eedc644b78d7 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -331,7 +331,7 @@ confused:
  *
  * then this code just gives up and calls the buffer_head-based read function.
  * It does handle a page which has holes at the end - that is a common case:
- * the end-of-file on blocksize < PAGE_CACHE_SIZE setups.
+ * the end-of-file on blocksize < PAGE_SIZE setups.
  *
  * BH_Boundary explanation:
  *
diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index a474e7ef92ea..97768a1379f2 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -674,7 +674,7 @@ static int ntfs_write_block(struct page *page, struct writeback_control *wbc)
                                 // in the inode.
                                 // Again, for each page do:
                                 //      __set_page_dirty_buffers();
-                                // page_cache_release()
+                                // put_page()
                                 // We don't need to wait on the writes.
                                 // Update iblock.
                         }
diff --git a/fs/ntfs/aops.h b/fs/ntfs/aops.h
index 37cd7e45dcbc..820d6eabf60f 100644
--- a/fs/ntfs/aops.h
+++ b/fs/ntfs/aops.h
@@ -49,7 +49,7 @@ static inline void ntfs_unmap_page(struct page *page)
  * @index:      index into the page cache for @mapping of the page to map
  *
  * Read a page from the page cache of the address space @mapping at position
- * @index, where @index is in units of PAGE_CACHE_SIZE, and not in bytes.
+ * @index, where @index is in units of PAGE_SIZE, and not in bytes.
  *
  * If the page is not in memory it is loaded from disk first using the readpage
  * method defined in the address space operations of @mapping and the page is
diff --git a/fs/ntfs/compress.c b/fs/ntfs/compress.c
index b6074a56661b..f2b5e746f49b 100644
--- a/fs/ntfs/compress.c
+++ b/fs/ntfs/compress.c
@@ -105,10 +105,6 @@ static void zero_partial_compressed_page(struct page *page,
 
         ntfs_debug("Zeroing page region outside initialized size.");
         if (((s64)page->index << PAGE_SHIFT) >= initialized_size) {
-                /*
-                 * FIXME: Using clear_page() will become wrong when we get
-                 * PAGE_CACHE_SIZE != PAGE_SIZE but for now there is no problem.
-                 */
                 clear_page(kp);
                 return;
         }
@@ -160,7 +156,7 @@ static inline void handle_bounds_compressed_page(struct page *page,
  * @xpage_done indicates whether the target page (@dest_pages[@xpage]) was
  * completed during the decompression of the compression block (@cb_start).
  *
- * Warning: This function *REQUIRES* PAGE_CACHE_SIZE >= 4096 or it will blow up
+ * Warning: This function *REQUIRES* PAGE_SIZE >= 4096 or it will blow up
  * unpredicatbly! You have been warned!
  *
  * Note to hackers: This function may not sleep until it has finished accessing
@@ -462,7 +458,7 @@ return_overflow:
  * have been written to so that we would lose data if we were to just overwrite
  * them with the out-of-date uncompressed data.
  *
- * FIXME: For PAGE_CACHE_SIZE > cb_size we are not doing the Right Thing(TM) at
+ * FIXME: For PAGE_SIZE > cb_size we are not doing the Right Thing(TM) at
  * the end of the file I think. We need to detect this case and zero the out
  * of bounds remainder of the page in question and mark it as handled. At the
  * moment we would just return -EIO on such a page. This bug will only become
@@ -470,7 +466,7 @@ return_overflow:
  * clusters so is probably not going to be seen by anyone. Still this should
  * be fixed. (AIA)
  *
- * FIXME: Again for PAGE_CACHE_SIZE > cb_size we are screwing up both in
+ * FIXME: Again for PAGE_SIZE > cb_size we are screwing up both in
  * handling sparse and compressed cbs. (AIA)
  *
  * FIXME: At the moment we don't do any zeroing out in the case that
@@ -497,12 +493,12 @@ int ntfs_read_compressed_block(struct page *page)
         u64 cb_size_mask = cb_size - 1UL;
         VCN vcn;
         LCN lcn;
-        /* The first wanted vcn (minimum alignment is PAGE_CACHE_SIZE). */
+        /* The first wanted vcn (minimum alignment is PAGE_SIZE). */
         VCN start_vcn = (((s64)index << PAGE_SHIFT) & ~cb_size_mask) >>
                         vol->cluster_size_bits;
         /*
          * The first vcn after the last wanted vcn (minimum alignment is again
-         * PAGE_CACHE_SIZE.
+         * PAGE_SIZE.
          */
         VCN end_vcn = ((((s64)(index + 1UL) << PAGE_SHIFT) + cb_size - 1)
                         & ~cb_size_mask) >> vol->cluster_size_bits;
@@ -753,11 +749,6 @@ lock_retry_remap:
                 for (; cur_page < cb_max_page; cur_page++) {
                         page = pages[cur_page];
                         if (page) {
-                                /*
-                                 * FIXME: Using clear_page() will become wrong
-                                 * when we get PAGE_CACHE_SIZE != PAGE_SIZE but
-                                 * for now there is no problem.
-                                 */
                                 if (likely(!cur_ofs))
                                         clear_page(page_address(page));
                                 else
@@ -807,7 +798,7 @@ lock_retry_remap:
                  * synchronous io for the majority of pages.
                  * Or if we choose not to do the read-ahead/-behind stuff, we
                  * could just return block_read_full_page(pages[xpage]) as long
-                 * as PAGE_CACHE_SIZE <= cb_size.
+                 * as PAGE_SIZE <= cb_size.
                  */
                 if (cb_max_ofs)
                         cb_max_page--;
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index 3cdce162592d..a18613579001 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -315,7 +315,7 @@ found_it:
 descend_into_child_node:
         /*
          * Convert vcn to index into the index allocation attribute in units
-         * of PAGE_CACHE_SIZE and map the page cache page, reading it from
+         * of PAGE_SIZE and map the page cache page, reading it from
          * disk if necessary.
          */
         page = ntfs_map_page(ia_mapping, vcn <<
@@ -793,11 +793,11 @@ found_it:
 descend_into_child_node:
         /*
          * Convert vcn to index into the index allocation attribute in units
-         * of PAGE_CACHE_SIZE and map the page cache page, reading it from
+         * of PAGE_SIZE and map the page cache page, reading it from
          * disk if necessary.
          */
         page = ntfs_map_page(ia_mapping, vcn <<
-                        dir_ni->itype.index.vcn_size_bits >> PAGE_CACHE_SHIFT);
+                        dir_ni->itype.index.vcn_size_bits >> PAGE_SHIFT);
         if (IS_ERR(page)) {
                 ntfs_error(sb, "Failed to map directory index page, error %ld.",
                                 -PTR_ERR(page));
@@ -809,9 +809,9 @@ descend_into_child_node:
 fast_descend_into_child_node:
         /* Get to the index allocation block. */
         ia = (INDEX_ALLOCATION*)(kaddr + ((vcn <<
-                        dir_ni->itype.index.vcn_size_bits) & ~PAGE_CACHE_MASK));
+                        dir_ni->itype.index.vcn_size_bits) & ~PAGE_MASK));
         /* Bounds checks. */
-        if ((u8*)ia < kaddr || (u8*)ia > kaddr + PAGE_CACHE_SIZE) {
+        if ((u8*)ia < kaddr || (u8*)ia > kaddr + PAGE_SIZE) {
                 ntfs_error(sb, "Out of bounds check failed. Corrupt directory "
                                 "inode 0x%lx or driver bug.", dir_ni->mft_no);
                 goto unm_err_out;
@@ -844,7 +844,7 @@ fast_descend_into_child_node:
                 goto unm_err_out;
         }
         index_end = (u8*)ia + dir_ni->itype.index.block_size;
-        if (index_end > kaddr + PAGE_CACHE_SIZE) {
+        if (index_end > kaddr + PAGE_SIZE) {
                 ntfs_error(sb, "Index buffer (VCN 0x%llx) of directory inode "
                                 "0x%lx crosses page boundary. Impossible! "
                                 "Cannot access! This is probably a bug in the "
@@ -968,9 +968,9 @@ found_it2:
                         /* If vcn is in the same page cache page as old_vcn we
                          * recycle the mapped page. */
                         if (old_vcn << vol->cluster_size_bits >>
-                                        PAGE_CACHE_SHIFT == vcn <<
+                                        PAGE_SHIFT == vcn <<
                                         vol->cluster_size_bits >>
-                                        PAGE_CACHE_SHIFT)
+                                        PAGE_SHIFT)
                                 goto fast_descend_into_child_node;
                         unlock_page(page);
                         ntfs_unmap_page(page);
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 2dae60857544..91117ada8528 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -573,7 +573,7 @@ static inline int ntfs_submit_bh_for_read(struct buffer_head *bh)
  * only partially being written to.
  *
  * If @nr_pages is greater than one, we are guaranteed that the cluster size is
- * greater than PAGE_CACHE_SIZE, that all pages in @pages are entirely inside
+ * greater than PAGE_SIZE, that all pages in @pages are entirely inside
  * the same cluster and that they are the entirety of that cluster, and that
  * the cluster is sparse, i.e. we need to allocate a cluster to fill the hole.
  *
diff --git a/fs/ntfs/index.c b/fs/ntfs/index.c
index 02a83a46ead2..0d645f357930 100644
--- a/fs/ntfs/index.c
+++ b/fs/ntfs/index.c
@@ -272,7 +272,7 @@ done:
 descend_into_child_node:
         /*
          * Convert vcn to index into the index allocation attribute in units
-         * of PAGE_CACHE_SIZE and map the page cache page, reading it from
+         * of PAGE_SIZE and map the page cache page, reading it from
          * disk if necessary.
          */
         page = ntfs_map_page(ia_mapping, vcn <<
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 3eda6d4bcc65..f40972d6df90 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -870,7 +870,7 @@ skip_attr_list_load:
                 }
                 if (ni->itype.index.block_size > PAGE_SIZE) {
                         ntfs_error(vi->i_sb, "Index block size (%u) > "
-                                        "PAGE_CACHE_SIZE (%ld) is not "
+                                        "PAGE_SIZE (%ld) is not "
                                         "supported.  Sorry.",
                                         ni->itype.index.block_size,
                                         PAGE_SIZE);
@@ -1586,7 +1586,7 @@ static int ntfs_read_locked_index_inode(struct inode *base_vi, struct inode *vi)
                 goto unm_err_out;
         }
         if (ni->itype.index.block_size > PAGE_SIZE) {
-                ntfs_error(vi->i_sb, "Index block size (%u) > PAGE_CACHE_SIZE "
+                ntfs_error(vi->i_sb, "Index block size (%u) > PAGE_SIZE "
                                 "(%ld) is not supported.  Sorry.",
                                 ni->itype.index.block_size, PAGE_SIZE);
                 err = -EOPNOTSUPP;
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index ab2b0930054e..ecb49870a680 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -823,12 +823,12 @@ static bool parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
         ntfs_debug("vol->mft_record_size_bits = %i (0x%x)",
                         vol->mft_record_size_bits, vol->mft_record_size_bits);
         /*
-         * We cannot support mft record sizes above the PAGE_CACHE_SIZE since
+         * We cannot support mft record sizes above the PAGE_SIZE since
          * we store $MFT/$DATA, the table of mft records in the page cache.
          */
         if (vol->mft_record_size > PAGE_SIZE) {
                 ntfs_error(vol->sb, "Mft record size (%i) exceeds the "
-                                "PAGE_CACHE_SIZE on your system (%lu).  "
+                                "PAGE_SIZE on your system (%lu).  "
                                 "This is not supported.  Sorry.",
                                 vol->mft_record_size, PAGE_SIZE);
                 return false;
@@ -2471,12 +2471,12 @@ static s64 get_nr_free_clusters(ntfs_volume *vol)
         down_read(&vol->lcnbmp_lock);
         /*
          * Convert the number of bits into bytes rounded up, then convert into
-         * multiples of PAGE_CACHE_SIZE, rounding up so that if we have one
+         * multiples of PAGE_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_SIZE - 1) >>
                         PAGE_SHIFT;
-        /* Use multiples of 4 bytes, thus max_size is PAGE_CACHE_SIZE / 4. */
+        /* Use multiples of 4 bytes, thus max_size is PAGE_SIZE / 4. */
         ntfs_debug("Reading $Bitmap, max_index = 0x%lx, max_size = 0x%lx.",
                         max_index, PAGE_SIZE / 4);
         for (index = 0; index < max_index; index++) {
@@ -2547,7 +2547,7 @@ static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
         pgoff_t index;
 
         ntfs_debug("Entering.");
-        /* Use multiples of 4 bytes, thus max_size is PAGE_CACHE_SIZE / 4. */
+        /* Use multiples of 4 bytes, thus max_size is PAGE_SIZE / 4. */
         ntfs_debug("Reading $MFT/$BITMAP, max_index = 0x%lx, max_size = "
                         "0x%lx.", max_index, PAGE_SIZE / 4);
         for (index = 0; index < max_index; index++) {
@@ -2639,7 +2639,7 @@ static int ntfs_statfs(struct dentry *dentry, struct kstatfs *sfs)
         size = i_size_read(vol->mft_ino) >> vol->mft_record_size_bits;
         /*
          * Convert the maximum number of set bits into bytes rounded up, then
-         * convert into multiples of PAGE_CACHE_SIZE, rounding up so that if we
+         * convert into multiples of PAGE_SIZE, rounding up so that if we
          * have one full and one partial page max_index = 2.
          */
         max_index = ((((mft_ni->initialized_size >> vol->mft_record_size_bits)
@@ -2765,7 +2765,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
         if (!parse_options(vol, (char*)opt))
                 goto err_out_now;
 
-        /* We support sector sizes up to the PAGE_CACHE_SIZE. */
+        /* We support sector sizes up to the PAGE_SIZE. */
         if (bdev_logical_block_size(sb->s_bdev) > PAGE_SIZE) {
                 if (!silent)
                         ntfs_error(sb, "Device has unsupported sector size "
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index ce5dc4f92935..ad1577348a92 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -684,7 +684,7 @@ next_bh:
         return ret;
 }
 
-#if (PAGE_CACHE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
+#if (PAGE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
 #define OCFS2_MAX_CTXT_PAGES    1
 #else
 #define OCFS2_MAX_CTXT_PAGES    (OCFS2_MAX_CLUSTERSIZE / PAGE_SIZE)
diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c
index 881242c3a8d2..744d5d90c363 100644
--- a/fs/ocfs2/refcounttree.c
+++ b/fs/ocfs2/refcounttree.c
@@ -2956,7 +2956,7 @@ int ocfs2_duplicate_clusters_by_page(handle_t *handle,
                 }
 
                 /*
-                 * In case PAGE_CACHE_SIZE <= CLUSTER_SIZE, This page
+                 * In case PAGE_SIZE <= CLUSTER_SIZE, This page
                  * can't be dirtied before we CoW it out.
                  */
                 if (PAGE_SIZE <= OCFS2_SB(sb)->s_clustersize)
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 8c6487238bb3..2ace90e981f0 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -599,7 +599,7 @@ static int journal_list_still_alive(struct super_block *s,
  * This does a check to see if the buffer belongs to one of these
  * lost pages before doing the final put_bh.  If page->mapping was
  * null, it tries to free buffers on the page, which should make the
- * final page_cache_release drop the page from the lru.
+ * final put_page drop the page from the lru.
  */
 static void release_buffer_page(struct buffer_head *bh)
 {
diff --git a/fs/squashfs/cache.c b/fs/squashfs/cache.c
index 27e501af0e8b..23813c078cc9 100644
--- a/fs/squashfs/cache.c
+++ b/fs/squashfs/cache.c
@@ -30,7 +30,7 @@
  * access the metadata and fragment caches.
  *
  * To avoid out of memory and fragmentation issues with vmalloc the cache
- * uses sequences of kmalloced PAGE_CACHE_SIZE buffers.
+ * uses sequences of kmalloced PAGE_SIZE buffers.
  *
  * It should be noted that the cache is not used for file datablocks, these
  * are decompressed and cached in the page-cache in the normal way.  The
@@ -231,7 +231,7 @@ void squashfs_cache_delete(struct squashfs_cache *cache)
 /*
  * Initialise cache allocating the specified number of entries, each of
  * size block_size.  To avoid vmalloc fragmentation issues each entry
- * is allocated as a sequence of kmalloced PAGE_CACHE_SIZE buffers.
+ * is allocated as a sequence of kmalloced PAGE_SIZE buffers.
  */
 struct squashfs_cache *squashfs_cache_init(char *name, int entries,
         int block_size)
diff --git a/fs/squashfs/file.c b/fs/squashfs/file.c
index 437de9e89221..13d80947bf9e 100644
--- a/fs/squashfs/file.c
+++ b/fs/squashfs/file.c
@@ -382,7 +382,7 @@ void squashfs_copy_cache(struct page *page, struct squashfs_cache_entry *buffer,
 
         /*
          * Loop copying datablock into pages.  As the datablock likely covers
-         * many PAGE_CACHE_SIZE pages (default block size is 128 KiB) explicitly
+         * many PAGE_SIZE pages (default block size is 128 KiB) explicitly
          * grab the pages from the page cache, except for the page that we've
          * been called to fill.
          */
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index 1a9c6640e604..446753d8ac34 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -554,7 +554,7 @@ static int ubifs_write_end(struct file *file, struct address_space *mapping,
                  * VFS copied less data to the page that it intended and
                  * declared in its '->write_begin()' call via the @len
                  * argument. If the page was not up-to-date, and @len was
-                 * @PAGE_CACHE_SIZE, the 'ubifs_write_begin()' function did
+                 * @PAGE_SIZE, the 'ubifs_write_begin()' function did
                  * not load it from the media (for optimization reasons). This
                  * means that part of the page contains garbage. So read the
                  * page now.
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index 20daea9aa657..e98c24ee25a1 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -2237,7 +2237,7 @@ static int __init ubifs_init(void)
         BUILD_BUG_ON(UBIFS_COMPR_TYPES_CNT > 4);
 
         /*
-         * We require that PAGE_CACHE_SIZE is greater-than-or-equal-to
+         * We require that PAGE_SIZE is greater-than-or-equal-to
          * UBIFS_BLOCK_SIZE. It is assumed that both are powers of 2.
          */
         if (PAGE_SIZE < UBIFS_BLOCK_SIZE) {
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 5b8ae03ba855..e49b2406d15d 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -1563,7 +1563,7 @@ xfs_vm_write_begin(
         int                     status;
         struct xfs_mount        *mp = XFS_I(mapping->host)->i_mount;
 
-        ASSERT(len <= PAGE_CACHE_SIZE);
+        ASSERT(len <= PAGE_SIZE);
 
         page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
@@ -1620,7 +1620,7 @@ xfs_vm_write_end(
 {
         int                     ret;
 
-        ASSERT(len <= PAGE_CACHE_SIZE);
+        ASSERT(len <= PAGE_SIZE);
 
         ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
         if (unlikely(ret < len)) {
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 6082f54e0557..187e14b696c2 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -556,10 +556,10 @@ xfs_max_file_offset(
         /* Figure out maximum filesize, on Linux this can depend on
          * the filesystem blocksize (on 32 bit platforms).
          * __block_write_begin does this in an [unsigned] long...
-         *      page->index << (PAGE_CACHE_SHIFT - bbits)
+         *      page->index << (PAGE_SHIFT - bbits)
          * So, for page sized blocks (4K on 32 bit platforms),
          * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
-         *      (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
+         *      (((u64)PAGE_SIZE << (BITS_PER_LONG-1))-1)
          * but for smaller blocksizes it is less (bbits = log2 bsize).
          * Note1: get_block_t takes a long (implicit cast from above)
          * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch