mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros

[mirror_ubuntu-artful-kernel.git] / fs / ecryptfs / mmap.c

diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 1f5865263b3eff32fed493480ce9ff7b72759af2..e6b1d80952b91d7dda9a3689fe018cf215ec5a11 100644 (file)
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -122,7 +122,7 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
                                       struct ecryptfs_crypt_stat *crypt_stat)
 {
        loff_t extent_num_in_page = 0;
-       loff_t num_extents_per_page = (PAGE_CACHE_SIZE
+       loff_t num_extents_per_page = (PAGE_SIZE
                                       / crypt_stat->extent_size);
        int rc = 0;
 
@@ -138,7 +138,7 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
                        char *page_virt;
 
                        page_virt = kmap_atomic(page);
-                       memset(page_virt, 0, PAGE_CACHE_SIZE);
+                       memset(page_virt, 0, PAGE_SIZE);
                        /* TODO: Support more than one header extent */
                        if (view_extent_num == 0) {
                                size_t written;
@@ -164,8 +164,8 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
                                 - crypt_stat->metadata_size);
 
                        rc = ecryptfs_read_lower_page_segment(
-                               page, (lower_offset >> PAGE_CACHE_SHIFT),
-                               (lower_offset & ~PAGE_CACHE_MASK),
+                               page, (lower_offset >> PAGE_SHIFT),
+                               (lower_offset & ~PAGE_MASK),
                                crypt_stat->extent_size, page->mapping->host);
                        if (rc) {
                                printk(KERN_ERR "%s: Error attempting to read "
@@ -198,7 +198,7 @@ static int ecryptfs_readpage(struct file *file, struct page *page)
 
        if (!crypt_stat || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
                rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
-                                                     PAGE_CACHE_SIZE,
+                                                     PAGE_SIZE,
                                                      page->mapping->host);
        } else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
                if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
@@ -215,7 +215,7 @@ static int ecryptfs_readpage(struct file *file, struct page *page)
 
                } else {
                        rc = ecryptfs_read_lower_page_segment(
-                               page, page->index, 0, PAGE_CACHE_SIZE,
+                               page, page->index, 0, PAGE_SIZE,
                                page->mapping->host);
                        if (rc) {
                                printk(KERN_ERR "Error reading page; rc = "
@@ -250,12 +250,12 @@ static int fill_zeros_to_end_of_page(struct page *page, unsigned int to)
        struct inode *inode = page->mapping->host;
        int end_byte_in_page;
 
-       if ((i_size_read(inode) / PAGE_CACHE_SIZE) != page->index)
+       if ((i_size_read(inode) / PAGE_SIZE) != page->index)
                goto out;
-       end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE;
+       end_byte_in_page = i_size_read(inode) % PAGE_SIZE;
        if (to > end_byte_in_page)
                end_byte_in_page = to;
-       zero_user_segment(page, end_byte_in_page, PAGE_CACHE_SIZE);
+       zero_user_segment(page, end_byte_in_page, PAGE_SIZE);
 out:
        return 0;
 }
@@ -279,7 +279,7 @@ static int ecryptfs_write_begin(struct file *file,
                        loff_t pos, unsigned len, unsigned flags,
                        struct page **pagep, void **fsdata)
 {
-       pgoff_t index = pos >> PAGE_CACHE_SHIFT;
+       pgoff_t index = pos >> PAGE_SHIFT;
        struct page *page;
        loff_t prev_page_end_size;
        int rc = 0;
@@ -289,14 +289,14 @@ static int ecryptfs_write_begin(struct file *file,
                return -ENOMEM;
        *pagep = page;
 
-       prev_page_end_size = ((loff_t)index << PAGE_CACHE_SHIFT);
+       prev_page_end_size = ((loff_t)index << PAGE_SHIFT);
        if (!PageUptodate(page)) {
                struct ecryptfs_crypt_stat *crypt_stat =
                        &ecryptfs_inode_to_private(mapping->host)->crypt_stat;
 
                if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
                        rc = ecryptfs_read_lower_page_segment(
-                               page, index, 0, PAGE_CACHE_SIZE, mapping->host);
+                               page, index, 0, PAGE_SIZE, mapping->host);
                        if (rc) {
                                printk(KERN_ERR "%s: Error attempting to read "
                                       "lower page segment; rc = [%d]\n",
@@ -322,7 +322,7 @@ static int ecryptfs_write_begin(struct file *file,
                                SetPageUptodate(page);
                        } else {
                                rc = ecryptfs_read_lower_page_segment(
-                                       page, index, 0, PAGE_CACHE_SIZE,
+                                       page, index, 0, PAGE_SIZE,
                                        mapping->host);
                                if (rc) {
                                        printk(KERN_ERR "%s: Error reading "
@@ -336,9 +336,9 @@ static int ecryptfs_write_begin(struct file *file,
                } else {
                        if (prev_page_end_size
                            >= i_size_read(page->mapping->host)) {
-                               zero_user(page, 0, PAGE_CACHE_SIZE);
+                               zero_user(page, 0, PAGE_SIZE);
                                SetPageUptodate(page);
-                       } else if (len < PAGE_CACHE_SIZE) {
+                       } else if (len < PAGE_SIZE) {
                                rc = ecryptfs_decrypt_page(page);
                                if (rc) {
                                        printk(KERN_ERR "%s: Error decrypting "
@@ -371,11 +371,11 @@ static int ecryptfs_write_begin(struct file *file,
         * of page?  Zero it out. */
        if ((i_size_read(mapping->host) == prev_page_end_size)
            && (pos != 0))
-               zero_user(page, 0, PAGE_CACHE_SIZE);
+               zero_user(page, 0, PAGE_SIZE);
 out:
        if (unlikely(rc)) {
                unlock_page(page);
-               page_cache_release(page);
+               put_page(page);
                *pagep = NULL;
        }
        return rc;
@@ -437,7 +437,7 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
        }
        inode_lock(lower_inode);
        size = lower_inode->i_op->getxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
-                                          xattr_virt, PAGE_CACHE_SIZE);
+                                          xattr_virt, PAGE_SIZE);
        if (size < 0)
                size = 8;
        put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt);
@@ -479,8 +479,8 @@ static int ecryptfs_write_end(struct file *file,
                        loff_t pos, unsigned len, unsigned copied,
                        struct page *page, void *fsdata)
 {
-       pgoff_t index = pos >> PAGE_CACHE_SHIFT;
-       unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+       pgoff_t index = pos >> PAGE_SHIFT;
+       unsigned from = pos & (PAGE_SIZE - 1);
        unsigned to = from + copied;
        struct inode *ecryptfs_inode = mapping->host;
        struct ecryptfs_crypt_stat *crypt_stat =
@@ -500,7 +500,7 @@ static int ecryptfs_write_end(struct file *file,
                goto out;
        }
        if (!PageUptodate(page)) {
-               if (copied < PAGE_CACHE_SIZE) {
+               if (copied < PAGE_SIZE) {
                        rc = 0;
                        goto out;
                }
@@ -533,7 +533,7 @@ static int ecryptfs_write_end(struct file *file,
                rc = copied;
 out:
        unlock_page(page);
-       page_cache_release(page);
+       put_page(page);
        return rc;
 }