[NETNS]: Consolidate kernel netlink socket destruction.

[linux-2.6] / fs / ecryptfs / mmap.c

diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 4eb09c1753c60df75331abbbd246299f697ecb78..32c5711d79a320593e9a536590f3b347905055bd 100644 (file)
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -37,23 +37,27 @@
 struct kmem_cache *ecryptfs_lower_page_cache;
 
 /**
- * ecryptfs_get1page
+ * ecryptfs_get_locked_page
  *
  * Get one page from cache or lower f/s, return error otherwise.
  *
- * Returns unlocked and up-to-date page (if ok), with increased
+ * Returns locked and up-to-date page (if ok), with increased
  * refcnt.
  */
-struct page *ecryptfs_get1page(struct file *file, loff_t index)
+struct page *ecryptfs_get_locked_page(struct file *file, loff_t index)
 {
        struct dentry *dentry;
        struct inode *inode;
        struct address_space *mapping;
+       struct page *page;
 
        dentry = file->f_path.dentry;
        inode = dentry->d_inode;
        mapping = inode->i_mapping;
-       return read_mapping_page(mapping, index, (void *)file);
+       page = read_mapping_page(mapping, index, (void *)file);
+       if (!IS_ERR(page))
+               lock_page(page);
+       return page;
 }
 
 /**
@@ -146,12 +150,10 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
                        kunmap_atomic(page_virt, KM_USER0);
                        flush_dcache_page(page);
                        if (rc) {
-                               ClearPageUptodate(page);
                                printk(KERN_ERR "%s: Error reading xattr "
                                       "region; rc = [%d]\n", __FUNCTION__, rc);
                                goto out;
                        }
-                       SetPageUptodate(page);
                } else {
                        /* This is an encrypted data extent */
                        loff_t lower_offset =
@@ -232,6 +234,10 @@ static int ecryptfs_readpage(struct file *file, struct page *page)
                }
        }
 out:
+       if (rc)
+               ClearPageUptodate(page);
+       else
+               SetPageUptodate(page);
        ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16x]\n",
                        page->index);
        unlock_page(page);
@@ -257,34 +263,51 @@ out:
        return 0;
 }
 
+/* This function must zero any hole we create */
 static int ecryptfs_prepare_write(struct file *file, struct page *page,
                                  unsigned from, unsigned to)
 {
        int rc = 0;
+       loff_t prev_page_end_size;
 
-       if (from == 0 && to == PAGE_CACHE_SIZE)
-               goto out;       /* If we are writing a full page, it will be
-                                  up to date. */
-       if (!PageUptodate(page))
+       if (!PageUptodate(page)) {
                rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
                                                      PAGE_CACHE_SIZE,
                                                      page->mapping->host);
-       if (page->index != 0) {
-               loff_t end_of_prev_pg_pos =
-                       (((loff_t)page->index << PAGE_CACHE_SHIFT) - 1);
+               if (rc) {
+                       printk(KERN_ERR "%s: Error attemping to read lower "
+                              "page segment; rc = [%d]\n", __FUNCTION__, rc);
+                       ClearPageUptodate(page);
+                       goto out;
+               } else
+                       SetPageUptodate(page);
+       }
 
-               if (end_of_prev_pg_pos > i_size_read(page->mapping->host)) {
+       prev_page_end_size = ((loff_t)page->index << PAGE_CACHE_SHIFT);
+
+       /*
+        * If creating a page or more of holes, zero them out via truncate.
+        * Note, this will increase i_size.
+        */
+       if (page->index != 0) {
+               if (prev_page_end_size > i_size_read(page->mapping->host)) {
                        rc = ecryptfs_truncate(file->f_path.dentry,
-                                              end_of_prev_pg_pos);
+                                              prev_page_end_size);
                        if (rc) {
                                printk(KERN_ERR "Error on attempt to "
                                       "truncate to (higher) offset [%lld];"
-                                      " rc = [%d]\n", end_of_prev_pg_pos, rc);
+                                      " rc = [%d]\n", prev_page_end_size, rc);
                                goto out;
                        }
                }
-               if (end_of_prev_pg_pos + 1 > i_size_read(page->mapping->host))
-                       zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+       }
+       /*
+        * Writing to a new page, and creating a small hole from start of page?
+        * Zero it out.
+        */
+       if ((i_size_read(page->mapping->host) == prev_page_end_size) &&
+           (from != 0)) {
+               zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
        }
 out:
        return rc;