[PATCH] eCryptfs: convert kmap() to kmap_atomic()

Replace kmap() with kmap_atomic().  Reduce the amount of time that mappings
are held.

Signed-off-by: Michael Halcrow <mhalcrow@us.ibm.com>
Signed-off-by: Trevor Highland <tshighla@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 2d7db61b9d6cc77ca926cd7e92d03013229ec46a..b817a1a39e70f03ccfa3685df0599c669988d749 100644 (file)
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -429,10 +429,10 @@ static int ecryptfs_read_in_page(struct ecryptfs_page_crypt_context *ctx,
                        goto out;
                }
        } else {
-               rc = ecryptfs_grab_and_map_lower_page(lower_page, NULL,
-                                                     lower_inode,
-                                                     lower_page_idx);
-               if (rc) {
+               *lower_page = grab_cache_page(lower_inode->i_mapping,
+                                             lower_page_idx);
+               if (!(*lower_page)) {
+                       rc = -EINVAL;
                        ecryptfs_printk(
                                KERN_ERR, "Error attempting to grab and map "
                                "lower page with index [0x%.16x]; rc = [%d]\n",

diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index ec526df4235efc6916981a292c76086a431d8fa3..31e628a3a1fa66ed5222012ddd33be8f7bd6a706 100644 (file)
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -514,10 +514,6 @@ int ecryptfs_copy_page_to_lower(struct page *page, struct inode *lower_inode,
                                struct file *lower_file);
 int ecryptfs_do_readpage(struct file *file, struct page *page,
                         pgoff_t lower_page_index);
-int ecryptfs_grab_and_map_lower_page(struct page **lower_page,
-                                    char **lower_virt,
-                                    struct inode *lower_inode,
-                                    unsigned long lower_page_index);
 int ecryptfs_writepage_and_release_lower_page(struct page *lower_page,
                                              struct inode *lower_inode,
                                              struct writeback_control *wbc);

diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 3386014becc6dde46b4e56770c0bcf6ae8eefce4..f5f962d7a123288d17195035c005441b26d7cbf5 100644 (file)
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -234,22 +234,11 @@ int ecryptfs_do_readpage(struct file *file, struct page *page,
                goto out;
        }
        wait_on_page_locked(lower_page);
-       page_data = (char *)kmap(page);
-       if (!page_data) {
-               rc = -ENOMEM;
-               ecryptfs_printk(KERN_ERR, "Error mapping page\n");
-               goto out;
-       }
-       lower_page_data = (char *)kmap(lower_page);
-       if (!lower_page_data) {
-               rc = -ENOMEM;
-               ecryptfs_printk(KERN_ERR, "Error mapping page\n");
-               kunmap(page);
-               goto out;
-       }
+       page_data = kmap_atomic(page, KM_USER0);
+       lower_page_data = kmap_atomic(lower_page, KM_USER1);
        memcpy(page_data, lower_page_data, PAGE_CACHE_SIZE);
-       kunmap(lower_page);
-       kunmap(page);
+       kunmap_atomic(lower_page_data, KM_USER1);
+       kunmap_atomic(page_data, KM_USER0);
        rc = 0;
 out:
        if (likely(lower_page))
@@ -325,19 +314,14 @@ static int ecryptfs_readpage(struct file *file, struct page *page)
                        if (page->index < num_pages_in_header_region) {
                                char *page_virt;
 
-                               page_virt = (char *)kmap(page);
-                               if (!page_virt) {
-                                       rc = -ENOMEM;
-                                       printk(KERN_ERR "Error mapping page\n");
-                                       goto out;
-                               }
+                               page_virt = kmap_atomic(page, KM_USER0);
                                memset(page_virt, 0, PAGE_CACHE_SIZE);
                                if (page->index == 0) {
                                        rc = ecryptfs_read_xattr_region(
                                                page_virt, file->f_path.dentry);
                                        set_header_info(page_virt, crypt_stat);
                                }
-                               kunmap(page);
+                               kunmap_atomic(page_virt, KM_USER0);
                                if (rc) {
                                        printk(KERN_ERR "Error reading xattr "
                                               "region\n");
@@ -387,26 +371,19 @@ 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;
-       int rc = 0;
        char *page_virt;
 
-       if ((i_size_read(inode) / PAGE_CACHE_SIZE) == page->index) {
-               end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE;
-               if (to > end_byte_in_page)
-                       end_byte_in_page = to;
-               page_virt = kmap(page);
-               if (!page_virt) {
-                       rc = -ENOMEM;
-                       ecryptfs_printk(KERN_WARNING,
-                                       "Could not map page\n");
-                       goto out;
-               }
-               memset((page_virt + end_byte_in_page), 0,
-                      (PAGE_CACHE_SIZE - end_byte_in_page));
-               kunmap(page);
-       }
+       if ((i_size_read(inode) / PAGE_CACHE_SIZE) != page->index)
+               goto out;
+       end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE;
+       if (to > end_byte_in_page)
+               end_byte_in_page = to;
+       page_virt = kmap_atomic(page, KM_USER0);
+       memset((page_virt + end_byte_in_page), 0,
+              (PAGE_CACHE_SIZE - end_byte_in_page));
+       kunmap_atomic(page_virt, KM_USER0);
 out:
-       return rc;
+       return 0;
 }
 
 static int ecryptfs_prepare_write(struct file *file, struct page *page,
@@ -414,7 +391,6 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page,
 {
        int rc = 0;
 
-       kmap(page);
        if (from == 0 && to == PAGE_CACHE_SIZE)
                goto out;       /* If we are writing a full page, it will be
                                   up to date. */
@@ -424,30 +400,6 @@ out:
        return rc;
 }
 
-int ecryptfs_grab_and_map_lower_page(struct page **lower_page,
-                                    char **lower_virt,
-                                    struct inode *lower_inode,
-                                    unsigned long lower_page_index)
-{
-       int rc = 0;
-
-       (*lower_page) = grab_cache_page(lower_inode->i_mapping,
-                                       lower_page_index);
-       if (!(*lower_page)) {
-               ecryptfs_printk(KERN_ERR, "grab_cache_page for "
-                               "lower_page_index = [0x%.16x] failed\n",
-                               lower_page_index);
-               rc = -EINVAL;
-               goto out;
-       }
-       if (lower_virt)
-               (*lower_virt) = kmap((*lower_page));
-       else
-               kmap((*lower_page));
-out:
-       return rc;
-}
-
 int ecryptfs_writepage_and_release_lower_page(struct page *lower_page,
                                              struct inode *lower_inode,
                                              struct writeback_control *wbc)
@@ -466,11 +418,8 @@ out:
        return rc;
 }
 
-static void ecryptfs_unmap_and_release_lower_page(struct page *lower_page)
+static void ecryptfs_release_lower_page(struct page *lower_page)
 {
-       kunmap(lower_page);
-       ecryptfs_printk(KERN_DEBUG, "Unlocking lower page with index = "
-                       "[0x%.16x]\n", lower_page->index);
        unlock_page(lower_page);
        page_cache_release(lower_page);
 }
@@ -492,11 +441,11 @@ static int ecryptfs_write_inode_size_to_header(struct file *lower_file,
        const struct address_space_operations *lower_a_ops;
        u64 file_size;
 
-       rc = ecryptfs_grab_and_map_lower_page(&header_page, &header_virt,
-                                             lower_inode, 0);
-       if (rc) {
-               ecryptfs_printk(KERN_ERR, "grab_cache_page for header page "
-                               "failed\n");
+       header_page = grab_cache_page(lower_inode->i_mapping, 0);
+       if (!header_page) {
+               ecryptfs_printk(KERN_ERR, "grab_cache_page for "
+                               "lower_page_index 0 failed\n");
+               rc = -EINVAL;
                goto out;
        }
        lower_a_ops = lower_inode->i_mapping->a_ops;
@@ -504,12 +453,14 @@ static int ecryptfs_write_inode_size_to_header(struct file *lower_file,
        file_size = (u64)i_size_read(inode);
        ecryptfs_printk(KERN_DEBUG, "Writing size: [0x%.16x]\n", file_size);
        file_size = cpu_to_be64(file_size);
+       header_virt = kmap_atomic(header_page, KM_USER0);
        memcpy(header_virt, &file_size, sizeof(u64));
+       kunmap_atomic(header_virt, KM_USER0);
        rc = lower_a_ops->commit_write(lower_file, header_page, 0, 8);
        if (rc < 0)
                ecryptfs_printk(KERN_ERR, "Error commiting header page "
                                "write\n");
-       ecryptfs_unmap_and_release_lower_page(header_page);
+       ecryptfs_release_lower_page(header_page);
        lower_inode->i_mtime = lower_inode->i_ctime = CURRENT_TIME;
        mark_inode_dirty_sync(inode);
 out:
@@ -597,10 +548,10 @@ int ecryptfs_get_lower_page(struct page **lower_page, struct inode *lower_inode,
 {
        int rc = 0;
 
-       rc = ecryptfs_grab_and_map_lower_page(lower_page, NULL, lower_inode,
-                                             lower_page_index);
-       if (rc) {
-               ecryptfs_printk(KERN_ERR, "Error attempting to grab and map "
+       *lower_page = grab_cache_page(lower_inode->i_mapping, lower_page_index);
+       if (!(*lower_page)) {
+               rc = -EINVAL;
+               ecryptfs_printk(KERN_ERR, "Error attempting to grab "
                                "lower page with index [0x%.16x]\n",
                                lower_page_index);
                goto out;
@@ -616,7 +567,7 @@ int ecryptfs_get_lower_page(struct page **lower_page, struct inode *lower_inode,
        }
 out:
        if (rc && (*lower_page)) {
-               ecryptfs_unmap_and_release_lower_page(*lower_page);
+               ecryptfs_release_lower_page(*lower_page);
                (*lower_page) = NULL;
        }
        return rc;
@@ -641,7 +592,7 @@ ecryptfs_commit_lower_page(struct page *lower_page, struct inode *lower_inode,
                                "Error committing write; rc = [%d]\n", rc);
        } else
                rc = 0;
-       ecryptfs_unmap_and_release_lower_page(lower_page);
+       ecryptfs_release_lower_page(lower_page);
        return rc;
 }
 
@@ -747,7 +698,6 @@ static int ecryptfs_commit_write(struct file *file, struct page *page,
        lower_inode->i_mtime = lower_inode->i_ctime = CURRENT_TIME;
        mark_inode_dirty_sync(inode);
 out:
-       kunmap(page); /* mapped in prior call (prepare_write) */
        if (rc < 0)
                ClearPageUptodate(page);
        else
@@ -772,6 +722,7 @@ int write_zeros(struct file *file, pgoff_t index, int start, int num_zeros)
 {
        int rc = 0;
        struct page *tmp_page;
+       char *tmp_page_virt;
 
        tmp_page = ecryptfs_get1page(file, index);
        if (IS_ERR(tmp_page)) {
@@ -780,28 +731,26 @@ int write_zeros(struct file *file, pgoff_t index, int start, int num_zeros)
                rc = PTR_ERR(tmp_page);
                goto out;
        }
-       kmap(tmp_page);
        rc = ecryptfs_prepare_write(file, tmp_page, start, start + num_zeros);
        if (rc) {
                ecryptfs_printk(KERN_ERR, "Error preparing to write zero's "
                                "to remainder of page at index [0x%.16x]\n",
                                index);
-               kunmap(tmp_page);
                page_cache_release(tmp_page);
                goto out;
        }
-       memset(((char *)page_address(tmp_page) + start), 0, num_zeros);
+       tmp_page_virt = kmap_atomic(tmp_page, KM_USER0);
+       memset(((char *)tmp_page_virt + start), 0, num_zeros);
+       kunmap_atomic(tmp_page_virt, KM_USER0);
        rc = ecryptfs_commit_write(file, tmp_page, start, start + num_zeros);
        if (rc < 0) {
                ecryptfs_printk(KERN_ERR, "Error attempting to write zero's "
                                "to remainder of page at index [0x%.16x]\n",
                                index);
-               kunmap(tmp_page);
                page_cache_release(tmp_page);
                goto out;
        }
        rc = 0;
-       kunmap(tmp_page);
        page_cache_release(tmp_page);
 out:
        return rc;