1 files changed, 50 insertions, 50 deletions

diff --git a/fs/buffer.c b/fs/buffer.c
index 33be29675358..af0d9a82a8ed 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -129,7 +129,7 @@ __clear_page_buffers(struct page *page)
 {
         ClearPagePrivate(page);
         set_page_private(page, 0);
-        page_cache_release(page);
+        put_page(page);
 }
 
 static void buffer_io_error(struct buffer_head *bh, char *msg)
@@ -207,7 +207,7 @@ __find_get_block_slow(struct block_device *bdev, sector_t block)
         struct page *page;
         int all_mapped = 1;
 
-        index = block >> (PAGE_CACHE_SHIFT - bd_inode->i_blkbits);
+        index = block >> (PAGE_SHIFT - bd_inode->i_blkbits);
         page = find_get_page_flags(bd_mapping, index, FGP_ACCESSED);
         if (!page)
                 goto out;
@@ -245,7 +245,7 @@ __find_get_block_slow(struct block_device *bdev, sector_t block)
         }
 out_unlock:
         spin_unlock(&bd_mapping->private_lock);
-        page_cache_release(page);
+        put_page(page);
 out:
         return ret;
 }
@@ -1040,7 +1040,7 @@ done:
         ret = (block < end_block) ? 1 : -ENXIO;
 failed:
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
         return ret;
 }
 
@@ -1533,7 +1533,7 @@ void block_invalidatepage(struct page *page, unsigned int offset,
         /*
          * Check for overflow
          */
-        BUG_ON(stop > PAGE_CACHE_SIZE || stop < length);
+        BUG_ON(stop > PAGE_SIZE || stop < length);
 
         head = page_buffers(page);
         bh = head;
@@ -1716,7 +1716,7 @@ static int __block_write_full_page(struct inode *inode, struct page *page,
         blocksize = bh->b_size;
         bbits = block_size_bits(blocksize);
 
-        block = (sector_t)page->index << (PAGE_CACHE_SHIFT - bbits);
+        block = (sector_t)page->index << (PAGE_SHIFT - bbits);
         last_block = (i_size_read(inode) - 1) >> bbits;
 
         /*
@@ -1894,7 +1894,7 @@ EXPORT_SYMBOL(page_zero_new_buffers);
 int __block_write_begin(struct page *page, loff_t pos, unsigned len,
                 get_block_t *get_block)
 {
-        unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+        unsigned from = pos & (PAGE_SIZE - 1);
         unsigned to = from + len;
         struct inode *inode = page->mapping->host;
         unsigned block_start, block_end;
@@ -1904,15 +1904,15 @@ int __block_write_begin(struct page *page, loff_t pos, unsigned len,
         struct buffer_head *bh, *head, *wait[2], **wait_bh=wait;
 
         BUG_ON(!PageLocked(page));
-        BUG_ON(from > PAGE_CACHE_SIZE);
-        BUG_ON(to > PAGE_CACHE_SIZE);
+        BUG_ON(from > PAGE_SIZE);
+        BUG_ON(to > PAGE_SIZE);
         BUG_ON(from > to);
 
         head = create_page_buffers(page, inode, 0);
         blocksize = head->b_size;
         bbits = block_size_bits(blocksize);
 
-        block = (sector_t)page->index << (PAGE_CACHE_SHIFT - bbits);
+        block = (sector_t)page->index << (PAGE_SHIFT - bbits);
 
         for(bh = head, block_start = 0; bh != head || !block_start;
             block++, block_start=block_end, bh = bh->b_this_page) {
@@ -2020,7 +2020,7 @@ static int __block_commit_write(struct inode *inode, struct page *page,
 int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
                 unsigned flags, struct page **pagep, get_block_t *get_block)
 {
-        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
+        pgoff_t index = pos >> PAGE_SHIFT;
         struct page *page;
         int status;
 
@@ -2031,7 +2031,7 @@ int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
         status = __block_write_begin(page, pos, len, get_block);
         if (unlikely(status)) {
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
                 page = NULL;
         }
 
@@ -2047,7 +2047,7 @@ int block_write_end(struct file *file, struct address_space *mapping,
         struct inode *inode = mapping->host;
         unsigned start;
 
-        start = pos & (PAGE_CACHE_SIZE - 1);
+        start = pos & (PAGE_SIZE - 1);
 
         if (unlikely(copied < len)) {
                 /*
@@ -2099,7 +2099,7 @@ int generic_write_end(struct file *file, struct address_space *mapping,
         }
 
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 
         if (old_size < pos)
                 pagecache_isize_extended(inode, old_size, pos);
@@ -2136,9 +2136,9 @@ int block_is_partially_uptodate(struct page *page, unsigned long from,
 
         head = page_buffers(page);
         blocksize = head->b_size;
-        to = min_t(unsigned, PAGE_CACHE_SIZE - from, count);
+        to = min_t(unsigned, PAGE_SIZE - from, count);
         to = from + to;
-        if (from < blocksize && to > PAGE_CACHE_SIZE - blocksize)
+        if (from < blocksize && to > PAGE_SIZE - blocksize)
                 return 0;
 
         bh = head;
@@ -2181,7 +2181,7 @@ int block_read_full_page(struct page *page, get_block_t *get_block)
         blocksize = head->b_size;
         bbits = block_size_bits(blocksize);
 
-        iblock = (sector_t)page->index << (PAGE_CACHE_SHIFT - bbits);
+        iblock = (sector_t)page->index << (PAGE_SHIFT - bbits);
         lblock = (i_size_read(inode)+blocksize-1) >> bbits;
         bh = head;
         nr = 0;
@@ -2295,16 +2295,16 @@ static int cont_expand_zero(struct file *file, struct address_space *mapping,
         unsigned zerofrom, offset, len;
         int err = 0;
 
-        index = pos >> PAGE_CACHE_SHIFT;
-        offset = pos & ~PAGE_CACHE_MASK;
+        index = pos >> PAGE_SHIFT;
+        offset = pos & ~PAGE_MASK;
 
-        while (index > (curidx = (curpos = *bytes)>>PAGE_CACHE_SHIFT)) {
-                zerofrom = curpos & ~PAGE_CACHE_MASK;
+        while (index > (curidx = (curpos = *bytes)>>PAGE_SHIFT)) {
+                zerofrom = curpos & ~PAGE_MASK;
                 if (zerofrom & (blocksize-1)) {
                         *bytes |= (blocksize-1);
                         (*bytes)++;
                 }
-                len = PAGE_CACHE_SIZE - zerofrom;
+                len = PAGE_SIZE - zerofrom;
 
                 err = pagecache_write_begin(file, mapping, curpos, len,
                                                 AOP_FLAG_UNINTERRUPTIBLE,
@@ -2329,7 +2329,7 @@ static int cont_expand_zero(struct file *file, struct address_space *mapping,
 
         /* page covers the boundary, find the boundary offset */
         if (index == curidx) {
-                zerofrom = curpos & ~PAGE_CACHE_MASK;
+                zerofrom = curpos & ~PAGE_MASK;
                 /* if we will expand the thing last block will be filled */
                 if (offset <= zerofrom) {
                         goto out;
@@ -2375,7 +2375,7 @@ int cont_write_begin(struct file *file, struct address_space *mapping,
         if (err)
                 return err;
 
-        zerofrom = *bytes & ~PAGE_CACHE_MASK;
+        zerofrom = *bytes & ~PAGE_MASK;
         if (pos+len > *bytes && zerofrom & (blocksize-1)) {
                 *bytes |= (blocksize-1);
                 (*bytes)++;
@@ -2430,10 +2430,10 @@ int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
         }
 
         /* page is wholly or partially inside EOF */
-        if (((page->index + 1) << PAGE_CACHE_SHIFT) > size)
-                end = size & ~PAGE_CACHE_MASK;
+        if (((page->index + 1) << PAGE_SHIFT) > size)
+                end = size & ~PAGE_MASK;
         else
-                end = PAGE_CACHE_SIZE;
+                end = PAGE_SIZE;
 
         ret = __block_write_begin(page, 0, end, get_block);
         if (!ret)
@@ -2508,8 +2508,8 @@ int nobh_write_begin(struct address_space *mapping,
         int ret = 0;
         int is_mapped_to_disk = 1;
 
-        index = pos >> PAGE_CACHE_SHIFT;
-        from = pos & (PAGE_CACHE_SIZE - 1);
+        index = pos >> PAGE_SHIFT;
+        from = pos & (PAGE_SIZE - 1);
         to = from + len;
 
         page = grab_cache_page_write_begin(mapping, index, flags);
@@ -2543,7 +2543,7 @@ int nobh_write_begin(struct address_space *mapping,
                 goto out_release;
         }
 
-        block_in_file = (sector_t)page->index << (PAGE_CACHE_SHIFT - blkbits);
+        block_in_file = (sector_t)page->index << (PAGE_SHIFT - blkbits);
 
         /*
          * We loop across all blocks in the page, whether or not they are
@@ -2551,7 +2551,7 @@ int nobh_write_begin(struct address_space *mapping,
          * page is fully mapped-to-disk.
          */
         for (block_start = 0, block_in_page = 0, bh = head;
-                  block_start < PAGE_CACHE_SIZE;
+                  block_start < PAGE_SIZE;
                   block_in_page++, block_start += blocksize, bh = bh->b_this_page) {
                 int create;
 
@@ -2623,7 +2623,7 @@ failed:
 
 out_release:
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
         *pagep = NULL;
 
         return ret;
@@ -2653,7 +2653,7 @@ int nobh_write_end(struct file *file, struct address_space *mapping,
         }
 
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 
         while (head) {
                 bh = head;
@@ -2675,7 +2675,7 @@ int nobh_writepage(struct page *page, get_block_t *get_block,
 {
         struct inode * const inode = page->mapping->host;
         loff_t i_size = i_size_read(inode);
-        const pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
+        const pgoff_t end_index = i_size >> PAGE_SHIFT;
         unsigned offset;
         int ret;
 
@@ -2684,7 +2684,7 @@ int nobh_writepage(struct page *page, get_block_t *get_block,
                 goto out;
 
         /* Is the page fully outside i_size? (truncate in progress) */
-        offset = i_size & (PAGE_CACHE_SIZE-1);
+        offset = i_size & (PAGE_SIZE-1);
         if (page->index >= end_index+1 || !offset) {
                 /*
                  * The page may have dirty, unmapped buffers.  For example,
@@ -2707,7 +2707,7 @@ int nobh_writepage(struct page *page, get_block_t *get_block,
          * the  page size, the remaining memory is zeroed when mapped, and
          * writes to that region are not written out to the file."
          */
-        zero_user_segment(page, offset, PAGE_CACHE_SIZE);
+        zero_user_segment(page, offset, PAGE_SIZE);
 out:
         ret = mpage_writepage(page, get_block, wbc);
         if (ret == -EAGAIN)
@@ -2720,8 +2720,8 @@ EXPORT_SYMBOL(nobh_writepage);
 int nobh_truncate_page(struct address_space *mapping,
                         loff_t from, get_block_t *get_block)
 {
-        pgoff_t index = from >> PAGE_CACHE_SHIFT;
-        unsigned offset = from & (PAGE_CACHE_SIZE-1);
+        pgoff_t index = from >> PAGE_SHIFT;
+        unsigned offset = from & (PAGE_SIZE-1);
         unsigned blocksize;
         sector_t iblock;
         unsigned length, pos;
@@ -2738,7 +2738,7 @@ int nobh_truncate_page(struct address_space *mapping,
                 return 0;
 
         length = blocksize - length;
-        iblock = (sector_t)index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+        iblock = (sector_t)index << (PAGE_SHIFT - inode->i_blkbits);
 
         page = grab_cache_page(mapping, index);
         err = -ENOMEM;
@@ -2748,7 +2748,7 @@ int nobh_truncate_page(struct address_space *mapping,
         if (page_has_buffers(page)) {
 has_buffers:
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
                 return block_truncate_page(mapping, from, get_block);
         }
 
@@ -2772,7 +2772,7 @@ has_buffers:
         if (!PageUptodate(page)) {
                 err = mapping->a_ops->readpage(NULL, page);
                 if (err) {
-                        page_cache_release(page);
+                        put_page(page);
                         goto out;
                 }
                 lock_page(page);
@@ -2789,7 +2789,7 @@ has_buffers:
 
 unlock:
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 out:
         return err;
 }
@@ -2798,8 +2798,8 @@ EXPORT_SYMBOL(nobh_truncate_page);
 int block_truncate_page(struct address_space *mapping,
                         loff_t from, get_block_t *get_block)
 {
-        pgoff_t index = from >> PAGE_CACHE_SHIFT;
-        unsigned offset = from & (PAGE_CACHE_SIZE-1);
+        pgoff_t index = from >> PAGE_SHIFT;
+        unsigned offset = from & (PAGE_SIZE-1);
         unsigned blocksize;
         sector_t iblock;
         unsigned length, pos;
@@ -2816,7 +2816,7 @@ int block_truncate_page(struct address_space *mapping,
                 return 0;
 
         length = blocksize - length;
-        iblock = (sector_t)index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+        iblock = (sector_t)index << (PAGE_SHIFT - inode->i_blkbits);
         
         page = grab_cache_page(mapping, index);
         err = -ENOMEM;
@@ -2865,7 +2865,7 @@ int block_truncate_page(struct address_space *mapping,
 
 unlock:
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 out:
         return err;
 }
@@ -2879,7 +2879,7 @@ int block_write_full_page(struct page *page, get_block_t *get_block,
 {
         struct inode * const inode = page->mapping->host;
         loff_t i_size = i_size_read(inode);
-        const pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
+        const pgoff_t end_index = i_size >> PAGE_SHIFT;
         unsigned offset;
 
         /* Is the page fully inside i_size? */
@@ -2888,14 +2888,14 @@ int block_write_full_page(struct page *page, get_block_t *get_block,
                                                end_buffer_async_write);
 
         /* Is the page fully outside i_size? (truncate in progress) */
-        offset = i_size & (PAGE_CACHE_SIZE-1);
+        offset = i_size & (PAGE_SIZE-1);
         if (page->index >= end_index+1 || !offset) {
                 /*
                  * The page may have dirty, unmapped buffers.  For example,
                  * they may have been added in ext3_writepage().  Make them
                  * freeable here, so the page does not leak.
                  */
-                do_invalidatepage(page, 0, PAGE_CACHE_SIZE);
+                do_invalidatepage(page, 0, PAGE_SIZE);
                 unlock_page(page);
                 return 0; /* don't care */
         }
@@ -2907,7 +2907,7 @@ int block_write_full_page(struct page *page, get_block_t *get_block,
          * the  page size, the remaining memory is zeroed when mapped, and
          * writes to that region are not written out to the file."
          */
-        zero_user_segment(page, offset, PAGE_CACHE_SIZE);
+        zero_user_segment(page, offset, PAGE_SIZE);
         return __block_write_full_page(inode, page, get_block, wbc,
                                                         end_buffer_async_write);
 }