1 files changed, 65 insertions, 65 deletions

diff --git a/mm/shmem.c b/mm/shmem.c
index 9428c51ab2d6..719bd6b88d98 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -75,8 +75,8 @@ static struct vfsmount *shm_mnt;
 
 #include "internal.h"
 
-#define BLOCKS_PER_PAGE  (PAGE_CACHE_SIZE/512)
-#define VM_ACCT(size)    (PAGE_CACHE_ALIGN(size) >> PAGE_SHIFT)
+#define BLOCKS_PER_PAGE  (PAGE_SIZE/512)
+#define VM_ACCT(size)    (PAGE_ALIGN(size) >> PAGE_SHIFT)
 
 /* Pretend that each entry is of this size in directory's i_size */
 #define BOGO_DIRENT_SIZE 20
@@ -176,13 +176,13 @@ static inline int shmem_reacct_size(unsigned long flags,
 static inline int shmem_acct_block(unsigned long flags)
 {
         return (flags & VM_NORESERVE) ?
-                security_vm_enough_memory_mm(current->mm, VM_ACCT(PAGE_CACHE_SIZE)) : 0;
+                security_vm_enough_memory_mm(current->mm, VM_ACCT(PAGE_SIZE)) : 0;
 }
 
 static inline void shmem_unacct_blocks(unsigned long flags, long pages)
 {
         if (flags & VM_NORESERVE)
-                vm_unacct_memory(pages * VM_ACCT(PAGE_CACHE_SIZE));
+                vm_unacct_memory(pages * VM_ACCT(PAGE_SIZE));
 }
 
 static const struct super_operations shmem_ops;
@@ -300,7 +300,7 @@ static int shmem_add_to_page_cache(struct page *page,
         VM_BUG_ON_PAGE(!PageLocked(page), page);
         VM_BUG_ON_PAGE(!PageSwapBacked(page), page);
 
-        page_cache_get(page);
+        get_page(page);
         page->mapping = mapping;
         page->index = index;
 
@@ -318,7 +318,7 @@ static int shmem_add_to_page_cache(struct page *page,
         } else {
                 page->mapping = NULL;
                 spin_unlock_irq(&mapping->tree_lock);
-                page_cache_release(page);
+                put_page(page);
         }
         return error;
 }
@@ -338,7 +338,7 @@ static void shmem_delete_from_page_cache(struct page *page, void *radswap)
         __dec_zone_page_state(page, NR_FILE_PAGES);
         __dec_zone_page_state(page, NR_SHMEM);
         spin_unlock_irq(&mapping->tree_lock);
-        page_cache_release(page);
+        put_page(page);
         BUG_ON(error);
 }
 
@@ -474,10 +474,10 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
 {
         struct address_space *mapping = inode->i_mapping;
         struct shmem_inode_info *info = SHMEM_I(inode);
-        pgoff_t start = (lstart + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-        pgoff_t end = (lend + 1) >> PAGE_CACHE_SHIFT;
-        unsigned int partial_start = lstart & (PAGE_CACHE_SIZE - 1);
-        unsigned int partial_end = (lend + 1) & (PAGE_CACHE_SIZE - 1);
+        pgoff_t start = (lstart + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        pgoff_t end = (lend + 1) >> PAGE_SHIFT;
+        unsigned int partial_start = lstart & (PAGE_SIZE - 1);
+        unsigned int partial_end = (lend + 1) & (PAGE_SIZE - 1);
         struct pagevec pvec;
         pgoff_t indices[PAGEVEC_SIZE];
         long nr_swaps_freed = 0;
@@ -530,7 +530,7 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
                 struct page *page = NULL;
                 shmem_getpage(inode, start - 1, &page, SGP_READ, NULL);
                 if (page) {
-                        unsigned int top = PAGE_CACHE_SIZE;
+                        unsigned int top = PAGE_SIZE;
                         if (start > end) {
                                 top = partial_end;
                                 partial_end = 0;
@@ -538,7 +538,7 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
                         zero_user_segment(page, partial_start, top);
                         set_page_dirty(page);
                         unlock_page(page);
-                        page_cache_release(page);
+                        put_page(page);
                 }
         }
         if (partial_end) {
@@ -548,7 +548,7 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
                         zero_user_segment(page, 0, partial_end);
                         set_page_dirty(page);
                         unlock_page(page);
-                        page_cache_release(page);
+                        put_page(page);
                 }
         }
         if (start >= end)
@@ -833,7 +833,7 @@ int shmem_unuse(swp_entry_t swap, struct page *page)
                 mem_cgroup_commit_charge(page, memcg, true, false);
 out:
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
         return error;
 }
 
@@ -1080,7 +1080,7 @@ static int shmem_replace_page(struct page **pagep, gfp_t gfp,
         if (!newpage)
                 return -ENOMEM;
 
-        page_cache_get(newpage);
+        get_page(newpage);
         copy_highpage(newpage, oldpage);
         flush_dcache_page(newpage);
 
@@ -1120,8 +1120,8 @@ static int shmem_replace_page(struct page **pagep, gfp_t gfp,
         set_page_private(oldpage, 0);
 
         unlock_page(oldpage);
-        page_cache_release(oldpage);
-        page_cache_release(oldpage);
+        put_page(oldpage);
+        put_page(oldpage);
         return error;
 }
 
@@ -1145,7 +1145,7 @@ static int shmem_getpage_gfp(struct inode *inode, pgoff_t index,
         int once = 0;
         int alloced = 0;
 
-        if (index > (MAX_LFS_FILESIZE >> PAGE_CACHE_SHIFT))
+        if (index > (MAX_LFS_FILESIZE >> PAGE_SHIFT))
                 return -EFBIG;
 repeat:
         swap.val = 0;
@@ -1156,7 +1156,7 @@ repeat:
         }
 
         if (sgp != SGP_WRITE && sgp != SGP_FALLOC &&
-            ((loff_t)index << PAGE_CACHE_SHIFT) >= i_size_read(inode)) {
+            ((loff_t)index << PAGE_SHIFT) >= i_size_read(inode)) {
                 error = -EINVAL;
                 goto unlock;
         }
@@ -1169,7 +1169,7 @@ repeat:
                 if (sgp != SGP_READ)
                         goto clear;
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
                 page = NULL;
         }
         if (page || (sgp == SGP_READ && !swap.val)) {
@@ -1327,7 +1327,7 @@ clear:
 
         /* Perhaps the file has been truncated since we checked */
         if (sgp != SGP_WRITE && sgp != SGP_FALLOC &&
-            ((loff_t)index << PAGE_CACHE_SHIFT) >= i_size_read(inode)) {
+            ((loff_t)index << PAGE_SHIFT) >= i_size_read(inode)) {
                 if (alloced) {
                         ClearPageDirty(page);
                         delete_from_page_cache(page);
@@ -1355,7 +1355,7 @@ failed:
 unlock:
         if (page) {
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
         }
         if (error == -ENOSPC && !once++) {
                 info = SHMEM_I(inode);
@@ -1577,7 +1577,7 @@ shmem_write_begin(struct file *file, struct address_space *mapping,
 {
         struct inode *inode = mapping->host;
         struct shmem_inode_info *info = SHMEM_I(inode);
-        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
+        pgoff_t index = pos >> PAGE_SHIFT;
 
         /* i_mutex is held by caller */
         if (unlikely(info->seals)) {
@@ -1601,16 +1601,16 @@ shmem_write_end(struct file *file, struct address_space *mapping,
                 i_size_write(inode, pos + copied);
 
         if (!PageUptodate(page)) {
-                if (copied < PAGE_CACHE_SIZE) {
-                        unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+                if (copied < PAGE_SIZE) {
+                        unsigned from = pos & (PAGE_SIZE - 1);
                         zero_user_segments(page, 0, from,
-                                        from + copied, PAGE_CACHE_SIZE);
+                                        from + copied, PAGE_SIZE);
                 }
                 SetPageUptodate(page);
         }
         set_page_dirty(page);
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 
         return copied;
 }
@@ -1635,8 +1635,8 @@ static ssize_t shmem_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
         if (!iter_is_iovec(to))
                 sgp = SGP_DIRTY;
 
-        index = *ppos >> PAGE_CACHE_SHIFT;
-        offset = *ppos & ~PAGE_CACHE_MASK;
+        index = *ppos >> PAGE_SHIFT;
+        offset = *ppos & ~PAGE_MASK;
 
         for (;;) {
                 struct page *page = NULL;
@@ -1644,11 +1644,11 @@ static ssize_t shmem_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
                 unsigned long nr, ret;
                 loff_t i_size = i_size_read(inode);
 
-                end_index = i_size >> PAGE_CACHE_SHIFT;
+                end_index = i_size >> PAGE_SHIFT;
                 if (index > end_index)
                         break;
                 if (index == end_index) {
-                        nr = i_size & ~PAGE_CACHE_MASK;
+                        nr = i_size & ~PAGE_MASK;
                         if (nr <= offset)
                                 break;
                 }
@@ -1666,14 +1666,14 @@ static ssize_t shmem_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
                  * We must evaluate after, since reads (unlike writes)
                  * are called without i_mutex protection against truncate
                  */
-                nr = PAGE_CACHE_SIZE;
+                nr = PAGE_SIZE;
                 i_size = i_size_read(inode);
-                end_index = i_size >> PAGE_CACHE_SHIFT;
+                end_index = i_size >> PAGE_SHIFT;
                 if (index == end_index) {
-                        nr = i_size & ~PAGE_CACHE_MASK;
+                        nr = i_size & ~PAGE_MASK;
                         if (nr <= offset) {
                                 if (page)
-                                        page_cache_release(page);
+                                        put_page(page);
                                 break;
                         }
                 }
@@ -1694,7 +1694,7 @@ static ssize_t shmem_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
                                 mark_page_accessed(page);
                 } else {
                         page = ZERO_PAGE(0);
-                        page_cache_get(page);
+                        get_page(page);
                 }
 
                 /*
@@ -1704,10 +1704,10 @@ static ssize_t shmem_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
                 ret = copy_page_to_iter(page, offset, nr, to);
                 retval += ret;
                 offset += ret;
-                index += offset >> PAGE_CACHE_SHIFT;
-                offset &= ~PAGE_CACHE_MASK;
+                index += offset >> PAGE_SHIFT;
+                offset &= ~PAGE_MASK;
 
-                page_cache_release(page);
+                put_page(page);
                 if (!iov_iter_count(to))
                         break;
                 if (ret < nr) {
@@ -1717,7 +1717,7 @@ static ssize_t shmem_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
                 cond_resched();
         }
 
-        *ppos = ((loff_t) index << PAGE_CACHE_SHIFT) + offset;
+        *ppos = ((loff_t) index << PAGE_SHIFT) + offset;
         file_accessed(file);
         return retval ? retval : error;
 }
@@ -1755,9 +1755,9 @@ static ssize_t shmem_file_splice_read(struct file *in, loff_t *ppos,
         if (splice_grow_spd(pipe, &spd))
                 return -ENOMEM;
 
-        index = *ppos >> PAGE_CACHE_SHIFT;
-        loff = *ppos & ~PAGE_CACHE_MASK;
-        req_pages = (len + loff + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+        index = *ppos >> PAGE_SHIFT;
+        loff = *ppos & ~PAGE_MASK;
+        req_pages = (len + loff + PAGE_SIZE - 1) >> PAGE_SHIFT;
         nr_pages = min(req_pages, spd.nr_pages_max);
 
         spd.nr_pages = find_get_pages_contig(mapping, index,
@@ -1774,7 +1774,7 @@ static ssize_t shmem_file_splice_read(struct file *in, loff_t *ppos,
                 index++;
         }
 
-        index = *ppos >> PAGE_CACHE_SHIFT;
+        index = *ppos >> PAGE_SHIFT;
         nr_pages = spd.nr_pages;
         spd.nr_pages = 0;
 
@@ -1784,7 +1784,7 @@ static ssize_t shmem_file_splice_read(struct file *in, loff_t *ppos,
                 if (!len)
                         break;
 
-                this_len = min_t(unsigned long, len, PAGE_CACHE_SIZE - loff);
+                this_len = min_t(unsigned long, len, PAGE_SIZE - loff);
                 page = spd.pages[page_nr];
 
                 if (!PageUptodate(page) || page->mapping != mapping) {
@@ -1793,19 +1793,19 @@ static ssize_t shmem_file_splice_read(struct file *in, loff_t *ppos,
                         if (error)
                                 break;
                         unlock_page(page);
-                        page_cache_release(spd.pages[page_nr]);
+                        put_page(spd.pages[page_nr]);
                         spd.pages[page_nr] = page;
                 }
 
                 isize = i_size_read(inode);
-                end_index = (isize - 1) >> PAGE_CACHE_SHIFT;
+                end_index = (isize - 1) >> PAGE_SHIFT;
                 if (unlikely(!isize || index > end_index))
                         break;
 
                 if (end_index == index) {
                         unsigned int plen;
 
-                        plen = ((isize - 1) & ~PAGE_CACHE_MASK) + 1;
+                        plen = ((isize - 1) & ~PAGE_MASK) + 1;
                         if (plen <= loff)
                                 break;
 
@@ -1822,7 +1822,7 @@ static ssize_t shmem_file_splice_read(struct file *in, loff_t *ppos,
         }
 
         while (page_nr < nr_pages)
-                page_cache_release(spd.pages[page_nr++]);
+                put_page(spd.pages[page_nr++]);
 
         if (spd.nr_pages)
                 error = splice_to_pipe(pipe, &spd);
@@ -1904,10 +1904,10 @@ static loff_t shmem_file_llseek(struct file *file, loff_t offset, int whence)
         else if (offset >= inode->i_size)
                 offset = -ENXIO;
         else {
-                start = offset >> PAGE_CACHE_SHIFT;
-                end = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+                start = offset >> PAGE_SHIFT;
+                end = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
                 new_offset = shmem_seek_hole_data(mapping, start, end, whence);
-                new_offset <<= PAGE_CACHE_SHIFT;
+                new_offset <<= PAGE_SHIFT;
                 if (new_offset > offset) {
                         if (new_offset < inode->i_size)
                                 offset = new_offset;
@@ -2203,8 +2203,8 @@ static long shmem_fallocate(struct file *file, int mode, loff_t offset,
                 goto out;
         }
 
-        start = offset >> PAGE_CACHE_SHIFT;
-        end = (offset + len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+        start = offset >> PAGE_SHIFT;
+        end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
         /* Try to avoid a swapstorm if len is impossible to satisfy */
         if (sbinfo->max_blocks && end - start > sbinfo->max_blocks) {
                 error = -ENOSPC;
@@ -2237,8 +2237,8 @@ static long shmem_fallocate(struct file *file, int mode, loff_t offset,
                 if (error) {
                         /* Remove the !PageUptodate pages we added */
                         shmem_undo_range(inode,
-                                (loff_t)start << PAGE_CACHE_SHIFT,
-                                (loff_t)index << PAGE_CACHE_SHIFT, true);
+                                (loff_t)start << PAGE_SHIFT,
+                                (loff_t)index << PAGE_SHIFT, true);
                         goto undone;
                 }
 
@@ -2259,7 +2259,7 @@ static long shmem_fallocate(struct file *file, int mode, loff_t offset,
                  */
                 set_page_dirty(page);
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
                 cond_resched();
         }
 
@@ -2280,7 +2280,7 @@ static int shmem_statfs(struct dentry *dentry, struct kstatfs *buf)
         struct shmem_sb_info *sbinfo = SHMEM_SB(dentry->d_sb);
 
         buf->f_type = TMPFS_MAGIC;
-        buf->f_bsize = PAGE_CACHE_SIZE;
+        buf->f_bsize = PAGE_SIZE;
         buf->f_namelen = NAME_MAX;
         if (sbinfo->max_blocks) {
                 buf->f_blocks = sbinfo->max_blocks;
@@ -2523,7 +2523,7 @@ static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *s
         struct shmem_inode_info *info;
 
         len = strlen(symname) + 1;
-        if (len > PAGE_CACHE_SIZE)
+        if (len > PAGE_SIZE)
                 return -ENAMETOOLONG;
 
         inode = shmem_get_inode(dir->i_sb, dir, S_IFLNK|S_IRWXUGO, 0, VM_NORESERVE);
@@ -2562,7 +2562,7 @@ static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *s
                 SetPageUptodate(page);
                 set_page_dirty(page);
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
         }
         dir->i_size += BOGO_DIRENT_SIZE;
         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
@@ -2835,7 +2835,7 @@ static int shmem_parse_options(char *options, struct shmem_sb_info *sbinfo,
                         if (*rest)
                                 goto bad_val;
                         sbinfo->max_blocks =
-                                DIV_ROUND_UP(size, PAGE_CACHE_SIZE);
+                                DIV_ROUND_UP(size, PAGE_SIZE);
                 } else if (!strcmp(this_char,"nr_blocks")) {
                         sbinfo->max_blocks = memparse(value, &rest);
                         if (*rest)
@@ -2940,7 +2940,7 @@ static int shmem_show_options(struct seq_file *seq, struct dentry *root)
 
         if (sbinfo->max_blocks != shmem_default_max_blocks())
                 seq_printf(seq, ",size=%luk",
-                        sbinfo->max_blocks << (PAGE_CACHE_SHIFT - 10));
+                        sbinfo->max_blocks << (PAGE_SHIFT - 10));
         if (sbinfo->max_inodes != shmem_default_max_inodes())
                 seq_printf(seq, ",nr_inodes=%lu", sbinfo->max_inodes);
         if (sbinfo->mode != (S_IRWXUGO | S_ISVTX))
@@ -3082,8 +3082,8 @@ int shmem_fill_super(struct super_block *sb, void *data, int silent)
         sbinfo->free_inodes = sbinfo->max_inodes;
 
         sb->s_maxbytes = MAX_LFS_FILESIZE;
-        sb->s_blocksize = PAGE_CACHE_SIZE;
-        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        sb->s_blocksize = PAGE_SIZE;
+        sb->s_blocksize_bits = PAGE_SHIFT;
         sb->s_magic = TMPFS_MAGIC;
         sb->s_op = &shmem_ops;
         sb->s_time_gran = 1;