Revert "ecryptfs: modify write path to encrypt page in writepage"

fs/ecryptfs/mmap.c

 /**
  * eCryptfs: Linux filesystem encryption layer
  * This is where eCryptfs coordinates the symmetric encryption and
  * decryption of the file data as it passes between the lower
  * encrypted file and the upper decrypted file.
  *
  * Copyright (C) 1997-2003 Erez Zadok
  * Copyright (C) 2001-2003 Stony Brook University
  * Copyright (C) 2004-2007 International Business Machines Corp.
  *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
@@ skipping 51 matching lines @@
 /**
  * ecryptfs_writepage
  * @page: Page that is locked before this call is made
  *
  * Returns zero on success; non-zero otherwise
  */
 static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc)
 {
         int rc;
 
-        /*
-         * Refuse to write the page out if we are called from reclaim context
-         * since our writepage() path may potentially allocate memory when
-         * calling into the lower fs vfs_write() which may in turn invoke
-         * us again.
-         */
-        if (current->flags & PF_MEMALLOC) {
-                redirty_page_for_writepage(wbc, page);
-                rc = 0;
-                goto out;
-        }
-
         rc = ecryptfs_encrypt_page(page);
         if (rc) {
                 ecryptfs_printk(KERN_WARNING, "Error encrypting "
                                 "page (upper index [0x%.16x])\n", page->index);
                 ClearPageUptodate(page);
                 goto out;
         }
         SetPageUptodate(page);
+        unlock_page(page);
 out:
-        unlock_page(page);
         return rc;
 }
 
 /**
  *   Header Extent:
  *     Octets 0-7:        Unencrypted file size (big-endian)
  *     Octets 8-15:       eCryptfs special marker
  *     Octets 16-19:      Flags
  *      Octet 16:         File format version number (between 0 and 255)
  *      Octets 17-18:     Reserved
@@ skipping 391 matching lines @@
                         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);
         unsigned to = from + copied;
         struct inode *ecryptfs_inode = mapping->host;
         struct ecryptfs_crypt_stat *crypt_stat =
                 &ecryptfs_inode_to_private(file->f_path.dentry->d_inode)->crypt_stat;
         int rc;
-        int need_unlock_page = 1;
 
         if (crypt_stat->flags & ECRYPTFS_NEW_FILE) {
                 ecryptfs_printk(KERN_DEBUG, "ECRYPTFS_NEW_FILE flag set in "
                         "crypt_stat at memory location [%p]\n", crypt_stat);
                 crypt_stat->flags &= ~(ECRYPTFS_NEW_FILE);
         } else
                 ecryptfs_printk(KERN_DEBUG, "Not a new file\n");
         ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"
                         "(page w/ index = [0x%.16x], to = [%d])\n", index, to);
         if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
                 rc = ecryptfs_write_lower_page_segment(ecryptfs_inode, page, 0,
                                                        to);
                 if (!rc) {
                         rc = copied;
                         fsstack_copy_inode_size(ecryptfs_inode,
                                 ecryptfs_inode_to_lower(ecryptfs_inode));
                 }
                 goto out;
         }
         /* Fills in zeros if 'to' goes beyond inode size */
         rc = fill_zeros_to_end_of_page(page, to);
         if (rc) {
                 ecryptfs_printk(KERN_WARNING, "Error attempting to fill "
                         "zeros in page with index = [0x%.16x]\n", index);
                 goto out;
         }
-        set_page_dirty(page);
-        unlock_page(page);
-        need_unlock_page = 0;
+        rc = ecryptfs_encrypt_page(page);
+        if (rc) {
+                ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
+                                "index [0x%.16x])\n", index);
+                goto out;
+        }
         if (pos + copied > i_size_read(ecryptfs_inode)) {
                 i_size_write(ecryptfs_inode, pos + copied);
                 ecryptfs_printk(KERN_DEBUG, "Expanded file size to "
                                 "[0x%.16x]\n", i_size_read(ecryptfs_inode));
-                balance_dirty_pages_ratelimited(mapping);
-                rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
-                if (rc) {
-                        printk(KERN_ERR "Error writing inode size to metadata; "
-                               "rc = [%d]\n", rc);
-                        goto out;
-                }
         }
-        rc = copied;
+        rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
+        if (rc)
+                printk(KERN_ERR "Error writing inode size to metadata; "
+                       "rc = [%d]\n", rc);
+        else
+                rc = copied;
 out:
-        if (need_unlock_page)
-                unlock_page(page);
+        unlock_page(page);
         page_cache_release(page);
         return rc;
 }
 
 static sector_t ecryptfs_bmap(struct address_space *mapping, sector_t block)
 {
         int rc = 0;
         struct inode *inode;
         struct inode *lower_inode;
 
         inode = (struct inode *)mapping->host;
         lower_inode = ecryptfs_inode_to_lower(inode);
         if (lower_inode->i_mapping->a_ops->bmap)
                 rc = lower_inode->i_mapping->a_ops->bmap(lower_inode->i_mapping,
                                                          block);
         return rc;
 }
 
 const struct address_space_operations ecryptfs_aops = {
         .writepage = ecryptfs_writepage,
         .readpage = ecryptfs_readpage,
         .write_begin = ecryptfs_write_begin,
         .write_end = ecryptfs_write_end,
         .bmap = ecryptfs_bmap,
 };