10 files changed, 58 insertions, 58 deletions

diff --git a/net/ceph/messenger.c b/net/ceph/messenger.c
index 1831f6353622..a5502898ea33 100644
--- a/net/ceph/messenger.c
+++ b/net/ceph/messenger.c
@@ -269,7 +269,7 @@ static void _ceph_msgr_exit(void)
         }
 
         BUG_ON(zero_page == NULL);
-        page_cache_release(zero_page);
+        put_page(zero_page);
         zero_page = NULL;
 
         ceph_msgr_slab_exit();
@@ -282,7 +282,7 @@ int ceph_msgr_init(void)
 
         BUG_ON(zero_page != NULL);
         zero_page = ZERO_PAGE(0);
-        page_cache_get(zero_page);
+        get_page(zero_page);
 
         /*
          * The number of active work items is limited by the number of
@@ -1602,7 +1602,7 @@ static int write_partial_skip(struct ceph_connection *con)
 
         dout("%s %p %d left\n", __func__, con, con->out_skip);
         while (con->out_skip > 0) {
-                size_t size = min(con->out_skip, (int) PAGE_CACHE_SIZE);
+                size_t size = min(con->out_skip, (int) PAGE_SIZE);
 
                 ret = ceph_tcp_sendpage(con->sock, zero_page, 0, size, true);
                 if (ret <= 0)
diff --git a/net/ceph/pagelist.c b/net/ceph/pagelist.c
index c7c220a736e5..6864007e64fc 100644
--- a/net/ceph/pagelist.c
+++ b/net/ceph/pagelist.c
@@ -56,7 +56,7 @@ int ceph_pagelist_append(struct ceph_pagelist *pl, const void *buf, size_t len)
                 size_t bit = pl->room;
                 int ret;
 
-                memcpy(pl->mapped_tail + (pl->length & ~PAGE_CACHE_MASK),
+                memcpy(pl->mapped_tail + (pl->length & ~PAGE_MASK),
                        buf, bit);
                 pl->length += bit;
                 pl->room -= bit;
@@ -67,7 +67,7 @@ int ceph_pagelist_append(struct ceph_pagelist *pl, const void *buf, size_t len)
                         return ret;
         }
 
-        memcpy(pl->mapped_tail + (pl->length & ~PAGE_CACHE_MASK), buf, len);
+        memcpy(pl->mapped_tail + (pl->length & ~PAGE_MASK), buf, len);
         pl->length += len;
         pl->room -= len;
         return 0;
diff --git a/net/ceph/pagevec.c b/net/ceph/pagevec.c
index 10297f7a89ba..00d2601407c5 100644
--- a/net/ceph/pagevec.c
+++ b/net/ceph/pagevec.c
@@ -95,19 +95,19 @@ int ceph_copy_user_to_page_vector(struct page **pages,
                                          loff_t off, size_t len)
 {
         int i = 0;
-        int po = off & ~PAGE_CACHE_MASK;
+        int po = off & ~PAGE_MASK;
         int left = len;
         int l, bad;
 
         while (left > 0) {
-                l = min_t(int, PAGE_CACHE_SIZE-po, left);
+                l = min_t(int, PAGE_SIZE-po, left);
                 bad = copy_from_user(page_address(pages[i]) + po, data, l);
                 if (bad == l)
                         return -EFAULT;
                 data += l - bad;
                 left -= l - bad;
                 po += l - bad;
-                if (po == PAGE_CACHE_SIZE) {
+                if (po == PAGE_SIZE) {
                         po = 0;
                         i++;
                 }
@@ -121,17 +121,17 @@ void ceph_copy_to_page_vector(struct page **pages,
                                     loff_t off, size_t len)
 {
         int i = 0;
-        size_t po = off & ~PAGE_CACHE_MASK;
+        size_t po = off & ~PAGE_MASK;
         size_t left = len;
 
         while (left > 0) {
-                size_t l = min_t(size_t, PAGE_CACHE_SIZE-po, left);
+                size_t l = min_t(size_t, PAGE_SIZE-po, left);
 
                 memcpy(page_address(pages[i]) + po, data, l);
                 data += l;
                 left -= l;
                 po += l;
-                if (po == PAGE_CACHE_SIZE) {
+                if (po == PAGE_SIZE) {
                         po = 0;
                         i++;
                 }
@@ -144,17 +144,17 @@ void ceph_copy_from_page_vector(struct page **pages,
                                     loff_t off, size_t len)
 {
         int i = 0;
-        size_t po = off & ~PAGE_CACHE_MASK;
+        size_t po = off & ~PAGE_MASK;
         size_t left = len;
 
         while (left > 0) {
-                size_t l = min_t(size_t, PAGE_CACHE_SIZE-po, left);
+                size_t l = min_t(size_t, PAGE_SIZE-po, left);
 
                 memcpy(data, page_address(pages[i]) + po, l);
                 data += l;
                 left -= l;
                 po += l;
-                if (po == PAGE_CACHE_SIZE) {
+                if (po == PAGE_SIZE) {
                         po = 0;
                         i++;
                 }
@@ -168,25 +168,25 @@ EXPORT_SYMBOL(ceph_copy_from_page_vector);
  */
 void ceph_zero_page_vector_range(int off, int len, struct page **pages)
 {
-        int i = off >> PAGE_CACHE_SHIFT;
+        int i = off >> PAGE_SHIFT;
 
-        off &= ~PAGE_CACHE_MASK;
+        off &= ~PAGE_MASK;
 
         dout("zero_page_vector_page %u~%u\n", off, len);
 
         /* leading partial page? */
         if (off) {
-                int end = min((int)PAGE_CACHE_SIZE, off + len);
+                int end = min((int)PAGE_SIZE, off + len);
                 dout("zeroing %d %p head from %d\n", i, pages[i],
                      (int)off);
                 zero_user_segment(pages[i], off, end);
                 len -= (end - off);
                 i++;
         }
-        while (len >= PAGE_CACHE_SIZE) {
+        while (len >= PAGE_SIZE) {
                 dout("zeroing %d %p len=%d\n", i, pages[i], len);
-                zero_user_segment(pages[i], 0, PAGE_CACHE_SIZE);
-                len -= PAGE_CACHE_SIZE;
+                zero_user_segment(pages[i], 0, PAGE_SIZE);
+                len -= PAGE_SIZE;
                 i++;
         }
         /* trailing partial page? */
diff --git a/net/sunrpc/auth_gss/auth_gss.c b/net/sunrpc/auth_gss/auth_gss.c
index 8c6bc795f060..15612ffa8d57 100644
--- a/net/sunrpc/auth_gss/auth_gss.c
+++ b/net/sunrpc/auth_gss/auth_gss.c
@@ -1728,8 +1728,8 @@ alloc_enc_pages(struct rpc_rqst *rqstp)
                 return 0;
         }
 
-        first = snd_buf->page_base >> PAGE_CACHE_SHIFT;
-        last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_CACHE_SHIFT;
+        first = snd_buf->page_base >> PAGE_SHIFT;
+        last = (snd_buf->page_base + snd_buf->page_len - 1) >> PAGE_SHIFT;
         rqstp->rq_enc_pages_num = last - first + 1 + 1;
         rqstp->rq_enc_pages
                 = kmalloc(rqstp->rq_enc_pages_num * sizeof(struct page *),
@@ -1775,10 +1775,10 @@ gss_wrap_req_priv(struct rpc_cred *cred, struct gss_cl_ctx *ctx,
         status = alloc_enc_pages(rqstp);
         if (status)
                 return status;
-        first = snd_buf->page_base >> PAGE_CACHE_SHIFT;
+        first = snd_buf->page_base >> PAGE_SHIFT;
         inpages = snd_buf->pages + first;
         snd_buf->pages = rqstp->rq_enc_pages;
-        snd_buf->page_base -= first << PAGE_CACHE_SHIFT;
+        snd_buf->page_base -= first << PAGE_SHIFT;
         /*
          * Give the tail its own page, in case we need extra space in the
          * head when wrapping:
diff --git a/net/sunrpc/auth_gss/gss_krb5_crypto.c b/net/sunrpc/auth_gss/gss_krb5_crypto.c
index d94a8e1e9f05..045e11ecd332 100644
--- a/net/sunrpc/auth_gss/gss_krb5_crypto.c
+++ b/net/sunrpc/auth_gss/gss_krb5_crypto.c
@@ -465,7 +465,7 @@ encryptor(struct scatterlist *sg, void *data)
         page_pos = desc->pos - outbuf->head[0].iov_len;
         if (page_pos >= 0 && page_pos < outbuf->page_len) {
                 /* pages are not in place: */
-                int i = (page_pos + outbuf->page_base) >> PAGE_CACHE_SHIFT;
+                int i = (page_pos + outbuf->page_base) >> PAGE_SHIFT;
                 in_page = desc->pages[i];
         } else {
                 in_page = sg_page(sg);
diff --git a/net/sunrpc/auth_gss/gss_krb5_wrap.c b/net/sunrpc/auth_gss/gss_krb5_wrap.c
index 765088e4ad84..a737c2da0837 100644
--- a/net/sunrpc/auth_gss/gss_krb5_wrap.c
+++ b/net/sunrpc/auth_gss/gss_krb5_wrap.c
@@ -79,9 +79,9 @@ gss_krb5_remove_padding(struct xdr_buf *buf, int blocksize)
                 len -= buf->head[0].iov_len;
         if (len <= buf->page_len) {
                 unsigned int last = (buf->page_base + len - 1)
-                                        >>PAGE_CACHE_SHIFT;
+                                        >>PAGE_SHIFT;
                 unsigned int offset = (buf->page_base + len - 1)
-                                        & (PAGE_CACHE_SIZE - 1);
+                                        & (PAGE_SIZE - 1);
                 ptr = kmap_atomic(buf->pages[last]);
                 pad = *(ptr + offset);
                 kunmap_atomic(ptr);
diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index 008c25d1b9f9..553bf95f7003 100644
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -881,7 +881,7 @@ static ssize_t cache_downcall(struct address_space *mapping,
         char *kaddr;
         ssize_t ret = -ENOMEM;
 
-        if (count >= PAGE_CACHE_SIZE)
+        if (count >= PAGE_SIZE)
                 goto out_slow;
 
         page = find_or_create_page(mapping, 0, GFP_KERNEL);
@@ -892,7 +892,7 @@ static ssize_t cache_downcall(struct address_space *mapping,
         ret = cache_do_downcall(kaddr, buf, count, cd);
         kunmap(page);
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
         return ret;
 out_slow:
         return cache_slow_downcall(buf, count, cd);
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 31789ef3e614..fc48eca21fd2 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -1390,8 +1390,8 @@ rpc_fill_super(struct super_block *sb, void *data, int silent)
         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
         int err;
 
-        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 = RPCAUTH_GSSMAGIC;
         sb->s_op = &s_ops;
         sb->s_d_op = &simple_dentry_operations;
diff --git a/net/sunrpc/socklib.c b/net/sunrpc/socklib.c
index 2df87f78e518..de70c78025d7 100644
--- a/net/sunrpc/socklib.c
+++ b/net/sunrpc/socklib.c
@@ -96,8 +96,8 @@ ssize_t xdr_partial_copy_from_skb(struct xdr_buf *xdr, unsigned int base, struct
         if (base || xdr->page_base) {
                 pglen -= base;
                 base += xdr->page_base;
-                ppage += base >> PAGE_CACHE_SHIFT;
-                base &= ~PAGE_CACHE_MASK;
+                ppage += base >> PAGE_SHIFT;
+                base &= ~PAGE_MASK;
         }
         do {
                 char *kaddr;
@@ -113,7 +113,7 @@ ssize_t xdr_partial_copy_from_skb(struct xdr_buf *xdr, unsigned int base, struct
                         }
                 }
 
-                len = PAGE_CACHE_SIZE;
+                len = PAGE_SIZE;
                 kaddr = kmap_atomic(*ppage);
                 if (base) {
                         len -= base;
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index 4439ac4c1b53..1e6aba0501a1 100644
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -181,20 +181,20 @@ _shift_data_right_pages(struct page **pages, size_t pgto_base,
         pgto_base += len;
         pgfrom_base += len;
 
-        pgto = pages + (pgto_base >> PAGE_CACHE_SHIFT);
-        pgfrom = pages + (pgfrom_base >> PAGE_CACHE_SHIFT);
+        pgto = pages + (pgto_base >> PAGE_SHIFT);
+        pgfrom = pages + (pgfrom_base >> PAGE_SHIFT);
 
-        pgto_base &= ~PAGE_CACHE_MASK;
-        pgfrom_base &= ~PAGE_CACHE_MASK;
+        pgto_base &= ~PAGE_MASK;
+        pgfrom_base &= ~PAGE_MASK;
 
         do {
                 /* Are any pointers crossing a page boundary? */
                 if (pgto_base == 0) {
-                        pgto_base = PAGE_CACHE_SIZE;
+                        pgto_base = PAGE_SIZE;
                         pgto--;
                 }
                 if (pgfrom_base == 0) {
-                        pgfrom_base = PAGE_CACHE_SIZE;
+                        pgfrom_base = PAGE_SIZE;
                         pgfrom--;
                 }
 
@@ -236,11 +236,11 @@ _copy_to_pages(struct page **pages, size_t pgbase, const char *p, size_t len)
         char *vto;
         size_t copy;
 
-        pgto = pages + (pgbase >> PAGE_CACHE_SHIFT);
-        pgbase &= ~PAGE_CACHE_MASK;
+        pgto = pages + (pgbase >> PAGE_SHIFT);
+        pgbase &= ~PAGE_MASK;
 
         for (;;) {
-                copy = PAGE_CACHE_SIZE - pgbase;
+                copy = PAGE_SIZE - pgbase;
                 if (copy > len)
                         copy = len;
 
@@ -253,7 +253,7 @@ _copy_to_pages(struct page **pages, size_t pgbase, const char *p, size_t len)
                         break;
 
                 pgbase += copy;
-                if (pgbase == PAGE_CACHE_SIZE) {
+                if (pgbase == PAGE_SIZE) {
                         flush_dcache_page(*pgto);
                         pgbase = 0;
                         pgto++;
@@ -280,11 +280,11 @@ _copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)
         char *vfrom;
         size_t copy;
 
-        pgfrom = pages + (pgbase >> PAGE_CACHE_SHIFT);
-        pgbase &= ~PAGE_CACHE_MASK;
+        pgfrom = pages + (pgbase >> PAGE_SHIFT);
+        pgbase &= ~PAGE_MASK;
 
         do {
-                copy = PAGE_CACHE_SIZE - pgbase;
+                copy = PAGE_SIZE - pgbase;
                 if (copy > len)
                         copy = len;
 
@@ -293,7 +293,7 @@ _copy_from_pages(char *p, struct page **pages, size_t pgbase, size_t len)
                 kunmap_atomic(vfrom);
 
                 pgbase += copy;
-                if (pgbase == PAGE_CACHE_SIZE) {
+                if (pgbase == PAGE_SIZE) {
                         pgbase = 0;
                         pgfrom++;
                 }
@@ -1038,8 +1038,8 @@ xdr_buf_subsegment(struct xdr_buf *buf, struct xdr_buf *subbuf,
         if (base < buf->page_len) {
                 subbuf->page_len = min(buf->page_len - base, len);
                 base += buf->page_base;
-                subbuf->page_base = base & ~PAGE_CACHE_MASK;
-                subbuf->pages = &buf->pages[base >> PAGE_CACHE_SHIFT];
+                subbuf->page_base = base & ~PAGE_MASK;
+                subbuf->pages = &buf->pages[base >> PAGE_SHIFT];
                 len -= subbuf->page_len;
                 base = 0;
         } else {
@@ -1297,9 +1297,9 @@ xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
                 todo -= avail_here;
 
                 base += buf->page_base;
-                ppages = buf->pages + (base >> PAGE_CACHE_SHIFT);
-                base &= ~PAGE_CACHE_MASK;
-                avail_page = min_t(unsigned int, PAGE_CACHE_SIZE - base,
+                ppages = buf->pages + (base >> PAGE_SHIFT);
+                base &= ~PAGE_MASK;
+                avail_page = min_t(unsigned int, PAGE_SIZE - base,
                                         avail_here);
                 c = kmap(*ppages) + base;
 
@@ -1383,7 +1383,7 @@ xdr_xcode_array2(struct xdr_buf *buf, unsigned int base,
                         }
 
                         avail_page = min(avail_here,
-                                 (unsigned int) PAGE_CACHE_SIZE);
+                                 (unsigned int) PAGE_SIZE);
                 }
                 base = buf->page_len;  /* align to start of tail */
         }
@@ -1479,9 +1479,9 @@ xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
                 if (page_len > len)
                         page_len = len;
                 len -= page_len;
-                page_offset = (offset + buf->page_base) & (PAGE_CACHE_SIZE - 1);
-                i = (offset + buf->page_base) >> PAGE_CACHE_SHIFT;
-                thislen = PAGE_CACHE_SIZE - page_offset;
+                page_offset = (offset + buf->page_base) & (PAGE_SIZE - 1);
+                i = (offset + buf->page_base) >> PAGE_SHIFT;
+                thislen = PAGE_SIZE - page_offset;
                 do {
                         if (thislen > page_len)
                                 thislen = page_len;
@@ -1492,7 +1492,7 @@ xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
                         page_len -= thislen;
                         i++;
                         page_offset = 0;
-                        thislen = PAGE_CACHE_SIZE;
+                        thislen = PAGE_SIZE;
                 } while (page_len != 0);
                 offset = 0;
         }