x86/platform/UV: Bring back the call to map_low_mmrs in uv_system_init

[deliverable/linux.git] / mm / shmem.c

diff --git a/mm/shmem.c b/mm/shmem.c
index 9428c51ab2d6b026ee9a10afc7e21c70e0a33d80..719bd6b88d98eaf0958ec57ddb152f22de0f74d0 100644 (file)
--- 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;