10 files changed, 201 insertions, 196 deletions

diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index f8ef0af919e7..a066e109ad9c 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -355,8 +355,11 @@ static int encrypt_scatterlist(struct ecryptfs_crypt_stat *crypt_stat,
         }
         /* Consider doing this once, when the file is opened */
         mutex_lock(&crypt_stat->cs_tfm_mutex);
-        rc = crypto_blkcipher_setkey(crypt_stat->tfm, crypt_stat->key,
-                                     crypt_stat->key_size);
+        if (!(crypt_stat->flags & ECRYPTFS_KEY_SET)) {
+                rc = crypto_blkcipher_setkey(crypt_stat->tfm, crypt_stat->key,
+                                             crypt_stat->key_size);
+                crypt_stat->flags |= ECRYPTFS_KEY_SET;
+        }
         if (rc) {
                 ecryptfs_printk(KERN_ERR, "Error setting key; rc = [%d]\n",
                                 rc);
@@ -376,11 +379,10 @@ out:
  *
  * Convert an eCryptfs page index into a lower byte offset
  */
-void ecryptfs_lower_offset_for_extent(loff_t *offset, loff_t extent_num,
-                                      struct ecryptfs_crypt_stat *crypt_stat)
+static void ecryptfs_lower_offset_for_extent(loff_t *offset, loff_t extent_num,
+                                             struct ecryptfs_crypt_stat *crypt_stat)
 {
-        (*offset) = ((crypt_stat->extent_size
-                      * crypt_stat->num_header_extents_at_front)
+        (*offset) = (crypt_stat->num_header_bytes_at_front
                      + (crypt_stat->extent_size * extent_num));
 }
 
@@ -842,15 +844,13 @@ void ecryptfs_set_default_sizes(struct ecryptfs_crypt_stat *crypt_stat)
         set_extent_mask_and_shift(crypt_stat);
         crypt_stat->iv_bytes = ECRYPTFS_DEFAULT_IV_BYTES;
         if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
-                crypt_stat->num_header_extents_at_front = 0;
+                crypt_stat->num_header_bytes_at_front = 0;
         else {
                 if (PAGE_CACHE_SIZE <= ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE)
-                        crypt_stat->num_header_extents_at_front =
-                                (ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE
-                                 / crypt_stat->extent_size);
+                        crypt_stat->num_header_bytes_at_front =
+                                ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
                 else
-                        crypt_stat->num_header_extents_at_front =
-                                (PAGE_CACHE_SIZE / crypt_stat->extent_size);
+                        crypt_stat->num_header_bytes_at_front = PAGE_CACHE_SIZE;
         }
 }
 
@@ -1128,7 +1128,7 @@ write_ecryptfs_flags(char *page_virt, struct ecryptfs_crypt_stat *crypt_stat,
 
 struct ecryptfs_cipher_code_str_map_elem {
         char cipher_str[16];
-        u16 cipher_code;
+        u8 cipher_code;
 };
 
 /* Add support for additional ciphers by adding elements here. The
@@ -1152,10 +1152,10 @@ ecryptfs_cipher_code_str_map[] = {
  *
  * Returns zero on no match, or the cipher code on match
  */
-u16 ecryptfs_code_for_cipher_string(struct ecryptfs_crypt_stat *crypt_stat)
+u8 ecryptfs_code_for_cipher_string(struct ecryptfs_crypt_stat *crypt_stat)
 {
         int i;
-        u16 code = 0;
+        u8 code = 0;
         struct ecryptfs_cipher_code_str_map_elem *map =
                 ecryptfs_cipher_code_str_map;
 
@@ -1187,7 +1187,7 @@ u16 ecryptfs_code_for_cipher_string(struct ecryptfs_crypt_stat *crypt_stat)
  *
  * Returns zero on success
  */
-int ecryptfs_cipher_code_to_string(char *str, u16 cipher_code)
+int ecryptfs_cipher_code_to_string(char *str, u8 cipher_code)
 {
         int rc = 0;
         int i;
@@ -1236,7 +1236,8 @@ ecryptfs_write_header_metadata(char *virt,
 
         header_extent_size = (u32)crypt_stat->extent_size;
         num_header_extents_at_front =
-                (u16)crypt_stat->num_header_extents_at_front;
+                (u16)(crypt_stat->num_header_bytes_at_front
+                      / crypt_stat->extent_size);
         header_extent_size = cpu_to_be32(header_extent_size);
         memcpy(virt, &header_extent_size, 4);
         virt += 4;
@@ -1311,40 +1312,16 @@ static int ecryptfs_write_headers_virt(char *page_virt, size_t *size,
 static int
 ecryptfs_write_metadata_to_contents(struct ecryptfs_crypt_stat *crypt_stat,
                                     struct dentry *ecryptfs_dentry,
-                                    char *page_virt)
+                                    char *virt)
 {
-        int current_header_page;
-        int header_pages;
         int rc;
 
-        rc = ecryptfs_write_lower(ecryptfs_dentry->d_inode, page_virt,
-                                  0, PAGE_CACHE_SIZE);
-        if (rc) {
+        rc = ecryptfs_write_lower(ecryptfs_dentry->d_inode, virt,
+                                  0, crypt_stat->num_header_bytes_at_front);
+        if (rc)
                 printk(KERN_ERR "%s: Error attempting to write header "
                        "information to lower file; rc = [%d]\n", __FUNCTION__,
                        rc);
-                goto out;
-        }
-        header_pages = ((crypt_stat->extent_size
-                         * crypt_stat->num_header_extents_at_front)
-                        / PAGE_CACHE_SIZE);
-        memset(page_virt, 0, PAGE_CACHE_SIZE);
-        current_header_page = 1;
-        while (current_header_page < header_pages) {
-                loff_t offset;
-
-                offset = (((loff_t)current_header_page) << PAGE_CACHE_SHIFT);
-                if ((rc = ecryptfs_write_lower(ecryptfs_dentry->d_inode,
-                                               page_virt, offset,
-                                               PAGE_CACHE_SIZE))) {
-                        printk(KERN_ERR "%s: Error attempting to write header "
-                               "information to lower file; rc = [%d]\n",
-                               __FUNCTION__, rc);
-                        goto out;
-                }
-                current_header_page++;
-        }
-out:
         return rc;
 }
 
@@ -1370,15 +1347,13 @@ ecryptfs_write_metadata_to_xattr(struct dentry *ecryptfs_dentry,
  * retrieved via a prompt.  Exactly what happens at this point should
  * be policy-dependent.
  *
- * TODO: Support header information spanning multiple pages
- *
  * Returns zero on success; non-zero on error
  */
 int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry)
 {
         struct ecryptfs_crypt_stat *crypt_stat =
                 &ecryptfs_inode_to_private(ecryptfs_dentry->d_inode)->crypt_stat;
-        char *page_virt;
+        char *virt;
         size_t size = 0;
         int rc = 0;
 
@@ -1389,40 +1364,39 @@ int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry)
                         goto out;
                 }
         } else {
+                printk(KERN_WARNING "%s: Encrypted flag not set\n",
+                       __FUNCTION__);
                 rc = -EINVAL;
-                ecryptfs_printk(KERN_WARNING,
-                                "Called with crypt_stat->encrypted == 0\n");
                 goto out;
         }
         /* Released in this function */
-        page_virt = kmem_cache_zalloc(ecryptfs_header_cache_0, GFP_USER);
-        if (!page_virt) {
-                ecryptfs_printk(KERN_ERR, "Out of memory\n");
+        virt = kzalloc(crypt_stat->num_header_bytes_at_front, GFP_KERNEL);
+        if (!virt) {
+                printk(KERN_ERR "%s: Out of memory\n", __FUNCTION__);
                 rc = -ENOMEM;
                 goto out;
         }
-        rc = ecryptfs_write_headers_virt(page_virt, &size, crypt_stat,
-                                         ecryptfs_dentry);
+        rc = ecryptfs_write_headers_virt(virt, &size, crypt_stat,
+                                         ecryptfs_dentry);
         if (unlikely(rc)) {
-                ecryptfs_printk(KERN_ERR, "Error whilst writing headers\n");
-                memset(page_virt, 0, PAGE_CACHE_SIZE);
+                printk(KERN_ERR "%s: Error whilst writing headers; rc = [%d]\n",
+                       __FUNCTION__, rc);
                 goto out_free;
         }
         if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
                 rc = ecryptfs_write_metadata_to_xattr(ecryptfs_dentry,
-                                                      crypt_stat, page_virt,
-                                                      size);
+                                                      crypt_stat, virt, size);
         else
                 rc = ecryptfs_write_metadata_to_contents(crypt_stat,
-                                                         ecryptfs_dentry,
-                                                         page_virt);
+                                                         ecryptfs_dentry, virt);
         if (rc) {
-                printk(KERN_ERR "Error writing metadata out to lower file; "
-                       "rc = [%d]\n", rc);
+                printk(KERN_ERR "%s: Error writing metadata out to lower file; "
+                       "rc = [%d]\n", __FUNCTION__, rc);
                 goto out_free;
         }
 out_free:
-        kmem_cache_free(ecryptfs_header_cache_0, page_virt);
+        memset(virt, 0, crypt_stat->num_header_bytes_at_front);
+        kfree(virt);
 out:
         return rc;
 }
@@ -1442,16 +1416,16 @@ static int parse_header_metadata(struct ecryptfs_crypt_stat *crypt_stat,
         virt += sizeof(u32);
         memcpy(&num_header_extents_at_front, virt, sizeof(u16));
         num_header_extents_at_front = be16_to_cpu(num_header_extents_at_front);
-        crypt_stat->num_header_extents_at_front =
-                (int)num_header_extents_at_front;
+        crypt_stat->num_header_bytes_at_front =
+                (((size_t)num_header_extents_at_front
+                  * (size_t)header_extent_size));
         (*bytes_read) = (sizeof(u32) + sizeof(u16));
         if ((validate_header_size == ECRYPTFS_VALIDATE_HEADER_SIZE)
-            && ((crypt_stat->extent_size
-                 * crypt_stat->num_header_extents_at_front)
+            && (crypt_stat->num_header_bytes_at_front
                 < ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE)) {
                 rc = -EINVAL;
-                printk(KERN_WARNING "Invalid number of header extents: [%zd]\n",
-                       crypt_stat->num_header_extents_at_front);
+                printk(KERN_WARNING "Invalid header size: [%zd]\n",
+                       crypt_stat->num_header_bytes_at_front);
         }
         return rc;
 }
@@ -1466,7 +1440,8 @@ static int parse_header_metadata(struct ecryptfs_crypt_stat *crypt_stat,
  */
 static void set_default_header_data(struct ecryptfs_crypt_stat *crypt_stat)
 {
-        crypt_stat->num_header_extents_at_front = 2;
+        crypt_stat->num_header_bytes_at_front =
+                ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
 }
 
 /**
@@ -1552,9 +1527,10 @@ int ecryptfs_read_xattr_region(char *page_virt, struct inode *ecryptfs_inode)
         size = ecryptfs_getxattr_lower(lower_dentry, ECRYPTFS_XATTR_NAME,
                                        page_virt, ECRYPTFS_DEFAULT_EXTENT_SIZE);
         if (size < 0) {
-                printk(KERN_ERR "Error attempting to read the [%s] "
-                       "xattr from the lower file; return value = [%zd]\n",
-                       ECRYPTFS_XATTR_NAME, size);
+                if (unlikely(ecryptfs_verbosity > 0))
+                        printk(KERN_INFO "Error attempting to read the [%s] "
+                               "xattr from the lower file; return value = "
+                               "[%zd]\n", ECRYPTFS_XATTR_NAME, size);
                 rc = -EINVAL;
                 goto out;
         }
@@ -1802,7 +1778,7 @@ out:
 }
 
 struct kmem_cache *ecryptfs_key_tfm_cache;
-struct list_head key_tfm_list;
+static struct list_head key_tfm_list;
 struct mutex key_tfm_list_mutex;
 
 int ecryptfs_init_crypto(void)
@@ -1812,6 +1788,11 @@ int ecryptfs_init_crypto(void)
         return 0;
 }
 
+/**
+ * ecryptfs_destroy_crypto - free all cached key_tfms on key_tfm_list
+ *
+ * Called only at module unload time
+ */
 int ecryptfs_destroy_crypto(void)
 {
         struct ecryptfs_key_tfm *key_tfm, *key_tfm_tmp;
@@ -1835,6 +1816,8 @@ ecryptfs_add_new_key_tfm(struct ecryptfs_key_tfm **key_tfm, char *cipher_name,
         struct ecryptfs_key_tfm *tmp_tfm;
         int rc = 0;
 
+        BUG_ON(!mutex_is_locked(&key_tfm_list_mutex));
+
         tmp_tfm = kmem_cache_alloc(ecryptfs_key_tfm_cache, GFP_KERNEL);
         if (key_tfm != NULL)
                 (*key_tfm) = tmp_tfm;
@@ -1861,13 +1844,50 @@ ecryptfs_add_new_key_tfm(struct ecryptfs_key_tfm **key_tfm, char *cipher_name,
                         (*key_tfm) = NULL;
                 goto out;
         }
-        mutex_lock(&key_tfm_list_mutex);
         list_add(&tmp_tfm->key_tfm_list, &key_tfm_list);
-        mutex_unlock(&key_tfm_list_mutex);
 out:
         return rc;
 }
 
+/**
+ * ecryptfs_tfm_exists - Search for existing tfm for cipher_name.
+ * @cipher_name: the name of the cipher to search for
+ * @key_tfm: set to corresponding tfm if found
+ *
+ * Searches for cached key_tfm matching @cipher_name
+ * Must be called with &key_tfm_list_mutex held
+ * Returns 1 if found, with @key_tfm set
+ * Returns 0 if not found, with @key_tfm set to NULL
+ */
+int ecryptfs_tfm_exists(char *cipher_name, struct ecryptfs_key_tfm **key_tfm)
+{
+        struct ecryptfs_key_tfm *tmp_key_tfm;
+
+        BUG_ON(!mutex_is_locked(&key_tfm_list_mutex));
+
+        list_for_each_entry(tmp_key_tfm, &key_tfm_list, key_tfm_list) {
+                if (strcmp(tmp_key_tfm->cipher_name, cipher_name) == 0) {
+                        if (key_tfm)
+                                (*key_tfm) = tmp_key_tfm;
+                        return 1;
+                }
+        }
+        if (key_tfm)
+                (*key_tfm) = NULL;
+        return 0;
+}
+
+/**
+ * ecryptfs_get_tfm_and_mutex_for_cipher_name
+ *
+ * @tfm: set to cached tfm found, or new tfm created
+ * @tfm_mutex: set to mutex for cached tfm found, or new tfm created
+ * @cipher_name: the name of the cipher to search for and/or add
+ *
+ * Sets pointers to @tfm & @tfm_mutex matching @cipher_name.
+ * Searches for cached item first, and creates new if not found.
+ * Returns 0 on success, non-zero if adding new cipher failed
+ */
 int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_blkcipher **tfm,
                                                struct mutex **tfm_mutex,
                                                char *cipher_name)
@@ -1877,22 +1897,17 @@ int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_blkcipher **tfm,
 
         (*tfm) = NULL;
         (*tfm_mutex) = NULL;
+
         mutex_lock(&key_tfm_list_mutex);
-        list_for_each_entry(key_tfm, &key_tfm_list, key_tfm_list) {
-                if (strcmp(key_tfm->cipher_name, cipher_name) == 0) {
-                        (*tfm) = key_tfm->key_tfm;
-                        (*tfm_mutex) = &key_tfm->key_tfm_mutex;
-                        mutex_unlock(&key_tfm_list_mutex);
+        if (!ecryptfs_tfm_exists(cipher_name, &key_tfm)) {
+                rc = ecryptfs_add_new_key_tfm(&key_tfm, cipher_name, 0);
+                if (rc) {
+                        printk(KERN_ERR "Error adding new key_tfm to list; "
+                                        "rc = [%d]\n", rc);
                         goto out;
                 }
         }
         mutex_unlock(&key_tfm_list_mutex);
-        rc = ecryptfs_add_new_key_tfm(&key_tfm, cipher_name, 0);
-        if (rc) {
-                printk(KERN_ERR "Error adding new key_tfm to list; rc = [%d]\n",
-                       rc);
-                goto out;
-        }
         (*tfm) = key_tfm->key_tfm;
         (*tfm_mutex) = &key_tfm->key_tfm_mutex;
 out:
diff --git a/fs/ecryptfs/dentry.c b/fs/ecryptfs/dentry.c
index cb20b964419f..841a032050a7 100644
--- a/fs/ecryptfs/dentry.c
+++ b/fs/ecryptfs/dentry.c
@@ -51,13 +51,13 @@ static int ecryptfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
 
         if (!lower_dentry->d_op || !lower_dentry->d_op->d_revalidate)
                 goto out;
-        dentry_save = nd->dentry;
-        vfsmount_save = nd->mnt;
-        nd->dentry = lower_dentry;
-        nd->mnt = lower_mnt;
+        dentry_save = nd->path.dentry;
+        vfsmount_save = nd->path.mnt;
+        nd->path.dentry = lower_dentry;
+        nd->path.mnt = lower_mnt;
         rc = lower_dentry->d_op->d_revalidate(lower_dentry, nd);
-        nd->dentry = dentry_save;
-        nd->mnt = vfsmount_save;
+        nd->path.dentry = dentry_save;
+        nd->path.mnt = vfsmount_save;
         if (dentry->d_inode) {
                 struct inode *lower_inode =
                         ecryptfs_inode_to_lower(dentry->d_inode);
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index ce7a5d4aec36..5007f788da01 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -234,10 +234,11 @@ struct ecryptfs_crypt_stat {
 #define ECRYPTFS_KEY_VALID          0x00000080
 #define ECRYPTFS_METADATA_IN_XATTR  0x00000100
 #define ECRYPTFS_VIEW_AS_ENCRYPTED  0x00000200
+#define ECRYPTFS_KEY_SET            0x00000400
         u32 flags;
         unsigned int file_version;
         size_t iv_bytes;
-        size_t num_header_extents_at_front;
+        size_t num_header_bytes_at_front;
         size_t extent_size; /* Data extent size; default is 4096 */
         size_t key_size;
         size_t extent_shift;
@@ -322,7 +323,6 @@ struct ecryptfs_key_tfm {
         unsigned char cipher_name[ECRYPTFS_MAX_CIPHER_NAME_SIZE + 1];
 };
 
-extern struct list_head key_tfm_list;
 extern struct mutex key_tfm_list_mutex;
 
 /**
@@ -521,11 +521,9 @@ extern struct kmem_cache *ecryptfs_file_info_cache;
 extern struct kmem_cache *ecryptfs_dentry_info_cache;
 extern struct kmem_cache *ecryptfs_inode_info_cache;
 extern struct kmem_cache *ecryptfs_sb_info_cache;
-extern struct kmem_cache *ecryptfs_header_cache_0;
 extern struct kmem_cache *ecryptfs_header_cache_1;
 extern struct kmem_cache *ecryptfs_header_cache_2;
 extern struct kmem_cache *ecryptfs_xattr_cache;
-extern struct kmem_cache *ecryptfs_lower_page_cache;
 extern struct kmem_cache *ecryptfs_key_record_cache;
 extern struct kmem_cache *ecryptfs_key_sig_cache;
 extern struct kmem_cache *ecryptfs_global_auth_tok_cache;
@@ -562,8 +560,8 @@ int ecryptfs_read_and_validate_header_region(char *data,
                                              struct inode *ecryptfs_inode);
 int ecryptfs_read_and_validate_xattr_region(char *page_virt,
                                             struct dentry *ecryptfs_dentry);
-u16 ecryptfs_code_for_cipher_string(struct ecryptfs_crypt_stat *crypt_stat);
-int ecryptfs_cipher_code_to_string(char *str, u16 cipher_code);
+u8 ecryptfs_code_for_cipher_string(struct ecryptfs_crypt_stat *crypt_stat);
+int ecryptfs_cipher_code_to_string(char *str, u8 cipher_code);
 void ecryptfs_set_default_sizes(struct ecryptfs_crypt_stat *crypt_stat);
 int ecryptfs_generate_key_packet_set(char *dest_base,
                                      struct ecryptfs_crypt_stat *crypt_stat,
@@ -576,8 +574,6 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length);
 int ecryptfs_inode_test(struct inode *inode, void *candidate_lower_inode);
 int ecryptfs_inode_set(struct inode *inode, void *lower_inode);
 void ecryptfs_init_inode(struct inode *inode, struct inode *lower_inode);
-ssize_t ecryptfs_getxattr(struct dentry *dentry, const char *name, void *value,
-                          size_t size);
 ssize_t
 ecryptfs_getxattr_lower(struct dentry *lower_dentry, const char *name,
                         void *value, size_t size);
@@ -623,6 +619,7 @@ ecryptfs_add_new_key_tfm(struct ecryptfs_key_tfm **key_tfm, char *cipher_name,
                          size_t key_size);
 int ecryptfs_init_crypto(void);
 int ecryptfs_destroy_crypto(void);
+int ecryptfs_tfm_exists(char *cipher_name, struct ecryptfs_key_tfm **key_tfm);
 int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_blkcipher **tfm,
                                                struct mutex **tfm_mutex,
                                                char *cipher_name);
@@ -631,8 +628,6 @@ int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
                                       char *sig);
 int ecryptfs_write_zeros(struct file *file, pgoff_t index, int start,
                          int num_zeros);
-void ecryptfs_lower_offset_for_extent(loff_t *offset, loff_t extent_num,
-                                      struct ecryptfs_crypt_stat *crypt_stat);
 int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
                          loff_t offset, size_t size);
 int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
@@ -646,8 +641,6 @@ int ecryptfs_read_lower_page_segment(struct page *page_for_ecryptfs,
                                      pgoff_t page_index,
                                      size_t offset_in_page, size_t size,
                                      struct inode *ecryptfs_inode);
-int ecryptfs_read(char *data, loff_t offset, size_t size,
-                  struct file *ecryptfs_file);
 struct page *ecryptfs_get_locked_page(struct file *file, loff_t index);
 
 #endif /* #ifndef ECRYPTFS_KERNEL_H */
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index c98c4690a771..2b8f5ed4adea 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -209,9 +209,10 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
                         if (!(mount_crypt_stat->flags
                               & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) {
                                 rc = -EIO;
-                                printk(KERN_WARNING "Attempt to read file that "
+                                printk(KERN_WARNING "Either the lower file "
                                        "is not in a valid eCryptfs format, "
-                                       "and plaintext passthrough mode is not "
+                                       "or the key could not be retrieved. "
+                                       "Plaintext passthrough mode is not "
                                        "enabled; returning -EIO\n");
                                 mutex_unlock(&crypt_stat->cs_mutex);
                                 goto out_free;
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 5a719180983c..e23861152101 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -77,13 +77,13 @@ ecryptfs_create_underlying_file(struct inode *lower_dir_inode,
         struct vfsmount *vfsmount_save;
         int rc;
 
-        dentry_save = nd->dentry;
-        vfsmount_save = nd->mnt;
-        nd->dentry = lower_dentry;
-        nd->mnt = lower_mnt;
+        dentry_save = nd->path.dentry;
+        vfsmount_save = nd->path.mnt;
+        nd->path.dentry = lower_dentry;
+        nd->path.mnt = lower_mnt;
         rc = vfs_create(lower_dir_inode, lower_dentry, mode, nd);
-        nd->dentry = dentry_save;
-        nd->mnt = vfsmount_save;
+        nd->path.dentry = dentry_save;
+        nd->path.mnt = vfsmount_save;
         return rc;
 }
 
@@ -365,8 +365,7 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
                 dentry->d_sb)->mount_crypt_stat;
         if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED) {
                 if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)
-                        file_size = ((crypt_stat->extent_size
-                                      * crypt_stat->num_header_extents_at_front)
+                        file_size = (crypt_stat->num_header_bytes_at_front
                                      + i_size_read(lower_dentry->d_inode));
                 else
                         file_size = i_size_read(lower_dentry->d_inode);
@@ -685,7 +684,7 @@ ecryptfs_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr)
  * @crypt_stat: Crypt_stat associated with file
  * @upper_size: Size of the upper file
  *
- * Calculate the requried size of the lower file based on the
+ * Calculate the required size of the lower file based on the
  * specified size of the upper file. This calculation is based on the
  * number of headers in the underlying file and the extent size.
  *
@@ -697,8 +696,7 @@ upper_size_to_lower_size(struct ecryptfs_crypt_stat *crypt_stat,
 {
         loff_t lower_size;
 
-        lower_size = (crypt_stat->extent_size
-                      * crypt_stat->num_header_extents_at_front);
+        lower_size = crypt_stat->num_header_bytes_at_front;
         if (upper_size != 0) {
                 loff_t num_extents;
 
@@ -821,14 +819,14 @@ ecryptfs_permission(struct inode *inode, int mask, struct nameidata *nd)
         int rc;
 
         if (nd) {
-                struct vfsmount *vfsmnt_save = nd->mnt;
-                struct dentry *dentry_save = nd->dentry;
+                struct vfsmount *vfsmnt_save = nd->path.mnt;
+                struct dentry *dentry_save = nd->path.dentry;
 
-                nd->mnt = ecryptfs_dentry_to_lower_mnt(nd->dentry);
-                nd->dentry = ecryptfs_dentry_to_lower(nd->dentry);
+                nd->path.mnt = ecryptfs_dentry_to_lower_mnt(nd->path.dentry);
+                nd->path.dentry = ecryptfs_dentry_to_lower(nd->path.dentry);
                 rc = permission(ecryptfs_inode_to_lower(inode), mask, nd);
-                nd->mnt = vfsmnt_save;
-                nd->dentry = dentry_save;
+                nd->path.mnt = vfsmnt_save;
+                nd->path.dentry = dentry_save;
         } else
                 rc = permission(ecryptfs_inode_to_lower(inode), mask, NULL);
         return rc;
@@ -875,11 +873,11 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
                         if (!(mount_crypt_stat->flags
                               & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) {
                                 rc = -EIO;
-                                printk(KERN_WARNING "Attempt to read file that "
+                                printk(KERN_WARNING "Either the lower file "
                                        "is not in a valid eCryptfs format, "
-                                       "and plaintext passthrough mode is not "
+                                       "or the key could not be retrieved. "
+                                       "Plaintext passthrough mode is not "
                                        "enabled; returning -EIO\n");
-
                                 mutex_unlock(&crypt_stat->cs_mutex);
                                 goto out;
                         }
@@ -954,7 +952,7 @@ out:
         return rc;
 }
 
-ssize_t
+static ssize_t
 ecryptfs_getxattr(struct dentry *dentry, const char *name, void *value,
                   size_t size)
 {
diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index f458c1f35565..682b1b2482c2 100644
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -189,7 +189,7 @@ out:
 }
 
 static int
-parse_tag_65_packet(struct ecryptfs_session_key *session_key, u16 *cipher_code,
+parse_tag_65_packet(struct ecryptfs_session_key *session_key, u8 *cipher_code,
                     struct ecryptfs_message *msg)
 {
         size_t i = 0;
@@ -275,7 +275,7 @@ out:
 
 
 static int
-write_tag_66_packet(char *signature, size_t cipher_code,
+write_tag_66_packet(char *signature, u8 cipher_code,
                     struct ecryptfs_crypt_stat *crypt_stat, char **packet,
                     size_t *packet_len)
 {
@@ -428,7 +428,7 @@ static int
 decrypt_pki_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
                                   struct ecryptfs_crypt_stat *crypt_stat)
 {
-        u16 cipher_code = 0;
+        u8 cipher_code = 0;
         struct ecryptfs_msg_ctx *msg_ctx;
         struct ecryptfs_message *msg = NULL;
         char *auth_tok_sig;
@@ -1537,7 +1537,7 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
         struct scatterlist dst_sg;
         struct scatterlist src_sg;
         struct mutex *tfm_mutex = NULL;
-        size_t cipher_code;
+        u8 cipher_code;
         size_t packet_size_length;
         size_t max_packet_size;
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 0249aa4ae181..d25ac9500a92 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -117,7 +117,7 @@ void __ecryptfs_printk(const char *fmt, ...)
  *
  * Returns zero on success; non-zero otherwise
  */
-int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
+static int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
 {
         struct ecryptfs_inode_info *inode_info =
                 ecryptfs_inode_to_private(ecryptfs_dentry->d_inode);
@@ -226,17 +226,15 @@ out:
         return rc;
 }
 
-enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig, ecryptfs_opt_debug,
-       ecryptfs_opt_ecryptfs_debug, ecryptfs_opt_cipher,
-       ecryptfs_opt_ecryptfs_cipher, ecryptfs_opt_ecryptfs_key_bytes,
+enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig,
+       ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher,
+       ecryptfs_opt_ecryptfs_key_bytes,
        ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata,
        ecryptfs_opt_encrypted_view, ecryptfs_opt_err };
 
 static match_table_t tokens = {
         {ecryptfs_opt_sig, "sig=%s"},
         {ecryptfs_opt_ecryptfs_sig, "ecryptfs_sig=%s"},
-        {ecryptfs_opt_debug, "debug=%u"},
-        {ecryptfs_opt_ecryptfs_debug, "ecryptfs_debug=%u"},
         {ecryptfs_opt_cipher, "cipher=%s"},
         {ecryptfs_opt_ecryptfs_cipher, "ecryptfs_cipher=%s"},
         {ecryptfs_opt_ecryptfs_key_bytes, "ecryptfs_key_bytes=%u"},
@@ -313,7 +311,6 @@ static int ecryptfs_parse_options(struct super_block *sb, char *options)
         substring_t args[MAX_OPT_ARGS];
         int token;
         char *sig_src;
-        char *debug_src;
         char *cipher_name_dst;
         char *cipher_name_src;
         char *cipher_key_bytes_src;
@@ -341,16 +338,6 @@ static int ecryptfs_parse_options(struct super_block *sb, char *options)
                         }
                         sig_set = 1;
                         break;
-                case ecryptfs_opt_debug:
-                case ecryptfs_opt_ecryptfs_debug:
-                        debug_src = args[0].from;
-                        ecryptfs_verbosity =
-                                (int)simple_strtol(debug_src, &debug_src,
-                                                   0);
-                        ecryptfs_printk(KERN_DEBUG,
-                                        "Verbosity set to [%d]" "\n",
-                                        ecryptfs_verbosity);
-                        break;
                 case ecryptfs_opt_cipher:
                 case ecryptfs_opt_ecryptfs_cipher:
                         cipher_name_src = args[0].from;
@@ -423,9 +410,13 @@ static int ecryptfs_parse_options(struct super_block *sb, char *options)
         if (!cipher_key_bytes_set) {
                 mount_crypt_stat->global_default_cipher_key_size = 0;
         }
-        rc = ecryptfs_add_new_key_tfm(
-                NULL, mount_crypt_stat->global_default_cipher_name,
-                mount_crypt_stat->global_default_cipher_key_size);
+        mutex_lock(&key_tfm_list_mutex);
+        if (!ecryptfs_tfm_exists(mount_crypt_stat->global_default_cipher_name,
+                                 NULL))
+                rc = ecryptfs_add_new_key_tfm(
+                        NULL, mount_crypt_stat->global_default_cipher_name,
+                        mount_crypt_stat->global_default_cipher_key_size);
+        mutex_unlock(&key_tfm_list_mutex);
         if (rc) {
                 printk(KERN_ERR "Error attempting to initialize cipher with "
                        "name = [%s] and key size = [%td]; rc = [%d]\n",
@@ -522,8 +513,8 @@ static int ecryptfs_read_super(struct super_block *sb, const char *dev_name)
                 ecryptfs_printk(KERN_WARNING, "path_lookup() failed\n");
                 goto out;
         }
-        lower_root = nd.dentry;
-        lower_mnt = nd.mnt;
+        lower_root = nd.path.dentry;
+        lower_mnt = nd.path.mnt;
         ecryptfs_set_superblock_lower(sb, lower_root->d_sb);
         sb->s_maxbytes = lower_root->d_sb->s_maxbytes;
         sb->s_blocksize = lower_root->d_sb->s_blocksize;
@@ -535,7 +526,7 @@ static int ecryptfs_read_super(struct super_block *sb, const char *dev_name)
         rc = 0;
         goto out;
 out_free:
-        path_release(&nd);
+        path_put(&nd.path);
 out:
         return rc;
 }
@@ -654,11 +645,6 @@ static struct ecryptfs_cache_info {
                 .size = sizeof(struct ecryptfs_sb_info),
         },
         {
-                .cache = &ecryptfs_header_cache_0,
-                .name = "ecryptfs_headers_0",
-                .size = PAGE_CACHE_SIZE,
-        },
-        {
                 .cache = &ecryptfs_header_cache_1,
                 .name = "ecryptfs_headers_1",
                 .size = PAGE_CACHE_SIZE,
@@ -821,6 +807,10 @@ static int __init ecryptfs_init(void)
                        "rc = [%d]\n", rc);
                 goto out_release_messaging;
         }
+        if (ecryptfs_verbosity > 0)
+                printk(KERN_CRIT "eCryptfs verbosity set to %d. Secret values "
+                        "will be written to the syslog!\n", ecryptfs_verbosity);
+
         goto out;
 out_release_messaging:
         ecryptfs_release_messaging(ecryptfs_transport);
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 32c5711d79a3..dc74b186145d 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -34,8 +34,6 @@
 #include <linux/scatterlist.h>
 #include "ecryptfs_kernel.h"
 
-struct kmem_cache *ecryptfs_lower_page_cache;
-
 /**
  * ecryptfs_get_locked_page
  *
@@ -102,13 +100,14 @@ static void set_header_info(char *page_virt,
                             struct ecryptfs_crypt_stat *crypt_stat)
 {
         size_t written;
-        int save_num_header_extents_at_front =
-                crypt_stat->num_header_extents_at_front;
+        size_t save_num_header_bytes_at_front =
+                crypt_stat->num_header_bytes_at_front;
 
-        crypt_stat->num_header_extents_at_front = 1;
+        crypt_stat->num_header_bytes_at_front =
+                ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE;
         ecryptfs_write_header_metadata(page_virt + 20, crypt_stat, &written);
-        crypt_stat->num_header_extents_at_front =
-                save_num_header_extents_at_front;
+        crypt_stat->num_header_bytes_at_front =
+                save_num_header_bytes_at_front;
 }
 
 /**
@@ -134,8 +133,11 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
                 loff_t view_extent_num = ((((loff_t)page->index)
                                            * num_extents_per_page)
                                           + extent_num_in_page);
+                size_t num_header_extents_at_front =
+                        (crypt_stat->num_header_bytes_at_front
+                         / crypt_stat->extent_size);
 
-                if (view_extent_num < crypt_stat->num_header_extents_at_front) {
+                if (view_extent_num < num_header_extents_at_front) {
                         /* This is a header extent */
                         char *page_virt;
 
@@ -157,9 +159,8 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
                 } else {
                         /* This is an encrypted data extent */
                         loff_t lower_offset =
-                                ((view_extent_num -
-                                  crypt_stat->num_header_extents_at_front)
-                                 * crypt_stat->extent_size);
+                                ((view_extent_num * crypt_stat->extent_size)
+                                 - crypt_stat->num_header_bytes_at_front);
 
                         rc = ecryptfs_read_lower_page_segment(
                                 page, (lower_offset >> PAGE_CACHE_SHIFT),
@@ -257,8 +258,7 @@ static int fill_zeros_to_end_of_page(struct page *page, unsigned int to)
         end_byte_in_page = i_size_read(inode) % PAGE_CACHE_SIZE;
         if (to > end_byte_in_page)
                 end_byte_in_page = to;
-        zero_user_page(page, end_byte_in_page,
-                PAGE_CACHE_SIZE - end_byte_in_page, KM_USER0);
+        zero_user_segment(page, end_byte_in_page, PAGE_CACHE_SIZE);
 out:
         return 0;
 }
@@ -307,7 +307,7 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page,
          */
         if ((i_size_read(page->mapping->host) == prev_page_end_size) &&
             (from != 0)) {
-                zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
+                zero_user(page, 0, PAGE_CACHE_SIZE);
         }
 out:
         return rc;
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index 948f57624c05..0c4928623bbc 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -293,6 +293,7 @@ int ecryptfs_read_lower_page_segment(struct page *page_for_ecryptfs,
         return rc;
 }
 
+#if 0
 /**
  * ecryptfs_read
  * @data: The virtual address into which to write the data read (and
@@ -371,3 +372,4 @@ int ecryptfs_read(char *data, loff_t offset, size_t size,
 out:
         return rc;
 }
+#endif  /*  0  */
diff --git a/fs/ecryptfs/super.c b/fs/ecryptfs/super.c
index 4859c4eecd65..c27ac2b358a1 100644
--- a/fs/ecryptfs/super.c
+++ b/fs/ecryptfs/super.c
@@ -156,32 +156,38 @@ static void ecryptfs_clear_inode(struct inode *inode)
 /**
  * ecryptfs_show_options
  *
- * Prints the directory we are currently mounted over.
- * Returns zero on success; non-zero otherwise
+ * Prints the mount options for a given superblock.
+ * Returns zero; does not fail.
  */
 static int ecryptfs_show_options(struct seq_file *m, struct vfsmount *mnt)
 {
         struct super_block *sb = mnt->mnt_sb;
-        struct dentry *lower_root_dentry = ecryptfs_dentry_to_lower(sb->s_root);
-        struct vfsmount *lower_mnt = ecryptfs_dentry_to_lower_mnt(sb->s_root);
-        char *tmp_page;
-        char *path;
-        int rc = 0;
-
-        tmp_page = (char *)__get_free_page(GFP_KERNEL);
-        if (!tmp_page) {
-                rc = -ENOMEM;
-                goto out;
-        }
-        path = d_path(lower_root_dentry, lower_mnt, tmp_page, PAGE_SIZE);
-        if (IS_ERR(path)) {
-                rc = PTR_ERR(path);
-                goto out;
+        struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
+                &ecryptfs_superblock_to_private(sb)->mount_crypt_stat;
+        struct ecryptfs_global_auth_tok *walker;
+
+        mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
+        list_for_each_entry(walker,
+                            &mount_crypt_stat->global_auth_tok_list,
+                            mount_crypt_stat_list) {
+                seq_printf(m, ",ecryptfs_sig=%s", walker->sig);
         }
-        seq_printf(m, ",dir=%s", path);
-        free_page((unsigned long)tmp_page);
-out:
-        return rc;
+        mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
+
+        seq_printf(m, ",ecryptfs_cipher=%s",
+                mount_crypt_stat->global_default_cipher_name);
+
+        if (mount_crypt_stat->global_default_cipher_key_size)
+                seq_printf(m, ",ecryptfs_key_bytes=%zd",
+                           mount_crypt_stat->global_default_cipher_key_size);
+        if (mount_crypt_stat->flags & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)
+                seq_printf(m, ",ecryptfs_passthrough");
+        if (mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED)
+                seq_printf(m, ",ecryptfs_xattr_metadata");
+        if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
+                seq_printf(m, ",ecryptfs_encrypted_view");
+
+        return 0;
 }
 
 const struct super_operations ecryptfs_sops = {