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

[mirror_ubuntu-zesty-kernel.git] / fs / ecryptfs / crypto.c

diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 11255cbcb2db34e8e7f1e52fad1cf79437c14b05..d09cb4cdd09f18e56e0f4135d810c732cc609365 100644 (file)
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -286,7 +286,7 @@ int virt_to_scatterlist(const void *addr, int size, struct scatterlist *sg,
                pg = virt_to_page(addr);
                offset = offset_in_page(addr);
                sg_set_page(&sg[i], pg, 0, offset);
-               remainder_of_page = PAGE_CACHE_SIZE - offset;
+               remainder_of_page = PAGE_SIZE - offset;
                if (size >= remainder_of_page) {
                        sg[i].length = remainder_of_page;
                        addr += remainder_of_page;
@@ -400,7 +400,7 @@ static loff_t lower_offset_for_page(struct ecryptfs_crypt_stat *crypt_stat,
                                    struct page *page)
 {
        return ecryptfs_lower_header_size(crypt_stat) +
-              ((loff_t)page->index << PAGE_CACHE_SHIFT);
+              ((loff_t)page->index << PAGE_SHIFT);
 }
 
 /**
@@ -428,7 +428,7 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
        size_t extent_size = crypt_stat->extent_size;
        int rc;
 
-       extent_base = (((loff_t)page_index) * (PAGE_CACHE_SIZE / extent_size));
+       extent_base = (((loff_t)page_index) * (PAGE_SIZE / extent_size));
        rc = ecryptfs_derive_iv(extent_iv, crypt_stat,
                                (extent_base + extent_offset));
        if (rc) {
@@ -498,7 +498,7 @@ int ecryptfs_encrypt_page(struct page *page)
        }
 
        for (extent_offset = 0;
-            extent_offset < (PAGE_CACHE_SIZE / crypt_stat->extent_size);
+            extent_offset < (PAGE_SIZE / crypt_stat->extent_size);
             extent_offset++) {
                rc = crypt_extent(crypt_stat, enc_extent_page, page,
                                  extent_offset, ENCRYPT);
@@ -512,7 +512,7 @@ int ecryptfs_encrypt_page(struct page *page)
        lower_offset = lower_offset_for_page(crypt_stat, page);
        enc_extent_virt = kmap(enc_extent_page);
        rc = ecryptfs_write_lower(ecryptfs_inode, enc_extent_virt, lower_offset,
-                                 PAGE_CACHE_SIZE);
+                                 PAGE_SIZE);
        kunmap(enc_extent_page);
        if (rc < 0) {
                ecryptfs_printk(KERN_ERR,
@@ -560,7 +560,7 @@ int ecryptfs_decrypt_page(struct page *page)
 
        lower_offset = lower_offset_for_page(crypt_stat, page);
        page_virt = kmap(page);
-       rc = ecryptfs_read_lower(page_virt, lower_offset, PAGE_CACHE_SIZE,
+       rc = ecryptfs_read_lower(page_virt, lower_offset, PAGE_SIZE,
                                 ecryptfs_inode);
        kunmap(page);
        if (rc < 0) {
@@ -571,7 +571,7 @@ int ecryptfs_decrypt_page(struct page *page)
        }
 
        for (extent_offset = 0;
-            extent_offset < (PAGE_CACHE_SIZE / crypt_stat->extent_size);
+            extent_offset < (PAGE_SIZE / crypt_stat->extent_size);
             extent_offset++) {
                rc = crypt_extent(crypt_stat, page, page,
                                  extent_offset, DECRYPT);
@@ -659,11 +659,11 @@ void ecryptfs_set_default_sizes(struct ecryptfs_crypt_stat *crypt_stat)
        if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
                crypt_stat->metadata_size = ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
        else {
-               if (PAGE_CACHE_SIZE <= ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE)
+               if (PAGE_SIZE <= ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE)
                        crypt_stat->metadata_size =
                                ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
                else
-                       crypt_stat->metadata_size = PAGE_CACHE_SIZE;
+                       crypt_stat->metadata_size = PAGE_SIZE;
        }
 }
 
@@ -1442,7 +1442,7 @@ int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry)
                                                ECRYPTFS_VALIDATE_HEADER_SIZE);
        if (rc) {
                /* metadata is not in the file header, so try xattrs */
-               memset(page_virt, 0, PAGE_CACHE_SIZE);
+               memset(page_virt, 0, PAGE_SIZE);
                rc = ecryptfs_read_xattr_region(page_virt, ecryptfs_inode);
                if (rc) {
                        printk(KERN_DEBUG "Valid eCryptfs headers not found in "
@@ -1475,7 +1475,7 @@ int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry)
        }
 out:
        if (page_virt) {
-               memset(page_virt, 0, PAGE_CACHE_SIZE);
+               memset(page_virt, 0, PAGE_SIZE);
                kmem_cache_free(ecryptfs_header_cache, page_virt);
        }
        return rc;
@@ -1492,16 +1492,14 @@ out:
  */
 static int
 ecryptfs_encrypt_filename(struct ecryptfs_filename *filename,
-                         struct ecryptfs_crypt_stat *crypt_stat,
                          struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
        int rc = 0;
 
        filename->encrypted_filename = NULL;
        filename->encrypted_filename_size = 0;
-       if ((crypt_stat && (crypt_stat->flags & ECRYPTFS_ENCFN_USE_MOUNT_FNEK))
-           || (mount_crypt_stat && (mount_crypt_stat->flags
-                                    & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK))) {
+       if (mount_crypt_stat && (mount_crypt_stat->flags
+                                    & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK)) {
                size_t packet_size;
                size_t remaining_bytes;
 
@@ -1933,7 +1931,6 @@ out:
 int ecryptfs_encrypt_and_encode_filename(
        char **encoded_name,
        size_t *encoded_name_size,
-       struct ecryptfs_crypt_stat *crypt_stat,
        struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
        const char *name, size_t name_size)
 {
@@ -1942,9 +1939,8 @@ int ecryptfs_encrypt_and_encode_filename(
 
        (*encoded_name) = NULL;
        (*encoded_name_size) = 0;
-       if ((crypt_stat && (crypt_stat->flags & ECRYPTFS_ENCRYPT_FILENAMES))
-           || (mount_crypt_stat && (mount_crypt_stat->flags
-                                    & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES))) {
+       if (mount_crypt_stat && (mount_crypt_stat->flags
+                                    & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)) {
                struct ecryptfs_filename *filename;
 
                filename = kzalloc(sizeof(*filename), GFP_KERNEL);
@@ -1957,8 +1953,7 @@ int ecryptfs_encrypt_and_encode_filename(
                }
                filename->filename = (char *)name;
                filename->filename_size = name_size;
-               rc = ecryptfs_encrypt_filename(filename, crypt_stat,
-                                              mount_crypt_stat);
+               rc = ecryptfs_encrypt_filename(filename, mount_crypt_stat);
                if (rc) {
                        printk(KERN_ERR "%s: Error attempting to encrypt "
                               "filename; rc = [%d]\n", __func__, rc);
@@ -1969,11 +1964,9 @@ int ecryptfs_encrypt_and_encode_filename(
                        NULL, &encoded_name_no_prefix_size,
                        filename->encrypted_filename,
                        filename->encrypted_filename_size);
-               if ((crypt_stat && (crypt_stat->flags
-                                   & ECRYPTFS_ENCFN_USE_MOUNT_FNEK))
-                   || (mount_crypt_stat
+               if (mount_crypt_stat
                        && (mount_crypt_stat->flags
-                           & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK)))
+                           & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK))
                        (*encoded_name_size) =
                                (ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE
                                 + encoded_name_no_prefix_size);
@@ -1991,11 +1984,9 @@ int ecryptfs_encrypt_and_encode_filename(
                        kfree(filename);
                        goto out;
                }
-               if ((crypt_stat && (crypt_stat->flags
-                                   & ECRYPTFS_ENCFN_USE_MOUNT_FNEK))
-                   || (mount_crypt_stat
+               if (mount_crypt_stat
                        && (mount_crypt_stat->flags
-                           & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK))) {
+                           & ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK)) {
                        memcpy((*encoded_name),
                               ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX,
                               ECRYPTFS_FNEK_ENCRYPTED_FILENAME_PREFIX_SIZE);