Merge branch 'linus' into x86/xen

10 files changed, 323 insertions, 148 deletions

diff --git a/fs/ecryptfs/Makefile b/fs/ecryptfs/Makefile
index 1e34a7fd4884..b4755a85996e 100644
--- a/fs/ecryptfs/Makefile
+++ b/fs/ecryptfs/Makefile
@@ -4,4 +4,4 @@
 
 obj-$(CONFIG_ECRYPT_FS) += ecryptfs.o
 
-ecryptfs-objs := dentry.o file.o inode.o main.o super.o mmap.o read_write.o crypto.o keystore.o messaging.o netlink.o miscdev.o debug.o
+ecryptfs-objs := dentry.o file.o inode.o main.o super.o mmap.o read_write.o crypto.o keystore.o messaging.o netlink.o miscdev.o kthread.o debug.o
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index e2832bc7869a..7b99917ffadc 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -33,6 +33,7 @@
 #include <linux/crypto.h>
 #include <linux/file.h>
 #include <linux/scatterlist.h>
+#include <asm/unaligned.h>
 #include "ecryptfs_kernel.h"
 
 static int
@@ -1032,10 +1033,8 @@ static int contains_ecryptfs_marker(char *data)
 {
         u32 m_1, m_2;
 
-        memcpy(&m_1, data, 4);
-        m_1 = be32_to_cpu(m_1);
-        memcpy(&m_2, (data + 4), 4);
-        m_2 = be32_to_cpu(m_2);
+        m_1 = get_unaligned_be32(data);
+        m_2 = get_unaligned_be32(data + 4);
         if ((m_1 ^ MAGIC_ECRYPTFS_MARKER) == m_2)
                 return 1;
         ecryptfs_printk(KERN_DEBUG, "m_1 = [0x%.8x]; m_2 = [0x%.8x]; "
@@ -1073,8 +1072,7 @@ static int ecryptfs_process_flags(struct ecryptfs_crypt_stat *crypt_stat,
         int i;
         u32 flags;
 
-        memcpy(&flags, page_virt, 4);
-        flags = be32_to_cpu(flags);
+        flags = get_unaligned_be32(page_virt);
         for (i = 0; i < ((sizeof(ecryptfs_flag_map)
                           / sizeof(struct ecryptfs_flag_map_elem))); i++)
                 if (flags & ecryptfs_flag_map[i].file_flag) {
@@ -1100,11 +1098,9 @@ static void write_ecryptfs_marker(char *page_virt, size_t *written)
 
         get_random_bytes(&m_1, (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES / 2));
         m_2 = (m_1 ^ MAGIC_ECRYPTFS_MARKER);
-        m_1 = cpu_to_be32(m_1);
-        memcpy(page_virt, &m_1, (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES / 2));
-        m_2 = cpu_to_be32(m_2);
-        memcpy(page_virt + (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES / 2), &m_2,
-               (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES / 2));
+        put_unaligned_be32(m_1, page_virt);
+        page_virt += (MAGIC_ECRYPTFS_MARKER_SIZE_BYTES / 2);
+        put_unaligned_be32(m_2, page_virt);
         (*written) = MAGIC_ECRYPTFS_MARKER_SIZE_BYTES;
 }
 
@@ -1121,8 +1117,7 @@ write_ecryptfs_flags(char *page_virt, struct ecryptfs_crypt_stat *crypt_stat,
                         flags |= ecryptfs_flag_map[i].file_flag;
         /* Version is in top 8 bits of the 32-bit flag vector */
         flags |= ((((u8)crypt_stat->file_version) << 24) & 0xFF000000);
-        flags = cpu_to_be32(flags);
-        memcpy(page_virt, &flags, 4);
+        put_unaligned_be32(flags, page_virt);
         (*written) = 4;
 }
 
@@ -1238,11 +1233,9 @@ ecryptfs_write_header_metadata(char *virt,
         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);
+        put_unaligned_be32(header_extent_size, virt);
         virt += 4;
-        num_header_extents_at_front = cpu_to_be16(num_header_extents_at_front);
-        memcpy(virt, &num_header_extents_at_front, 2);
+        put_unaligned_be16(num_header_extents_at_front, virt);
         (*written) = 6;
 }
 
@@ -1410,15 +1403,13 @@ static int parse_header_metadata(struct ecryptfs_crypt_stat *crypt_stat,
         u32 header_extent_size;
         u16 num_header_extents_at_front;
 
-        memcpy(&header_extent_size, virt, sizeof(u32));
-        header_extent_size = be32_to_cpu(header_extent_size);
-        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);
+        header_extent_size = get_unaligned_be32(virt);
+        virt += sizeof(__be32);
+        num_header_extents_at_front = get_unaligned_be16(virt);
         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));
+        (*bytes_read) = (sizeof(__be32) + sizeof(__be16));
         if ((validate_header_size == ECRYPTFS_VALIDATE_HEADER_SIZE)
             && (crypt_stat->num_header_bytes_at_front
                 < ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE)) {
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index c15c25745e05..b73fb752c5f8 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -559,10 +559,25 @@ 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;
 extern struct kmem_cache *ecryptfs_key_tfm_cache;
+extern struct kmem_cache *ecryptfs_open_req_cache;
 
+struct ecryptfs_open_req {
+#define ECRYPTFS_REQ_PROCESSED 0x00000001
+#define ECRYPTFS_REQ_DROPPED   0x00000002
+#define ECRYPTFS_REQ_ZOMBIE    0x00000004
+        u32 flags;
+        struct file **lower_file;
+        struct dentry *lower_dentry;
+        struct vfsmount *lower_mnt;
+        wait_queue_head_t wait;
+        struct mutex mux;
+        struct list_head kthread_ctl_list;
+};
+
+#define ECRYPTFS_INTERPOSE_FLAG_D_ADD                 0x00000001
 int ecryptfs_interpose(struct dentry *hidden_dentry,
                        struct dentry *this_dentry, struct super_block *sb,
-                       int flag);
+                       u32 flags);
 int ecryptfs_fill_zeros(struct file *file, loff_t new_length);
 int ecryptfs_decode_filename(struct ecryptfs_crypt_stat *crypt_stat,
                              const char *name, int length,
@@ -690,5 +705,11 @@ void ecryptfs_msg_ctx_alloc_to_free(struct ecryptfs_msg_ctx *msg_ctx);
 int
 ecryptfs_spawn_daemon(struct ecryptfs_daemon **daemon, uid_t euid,
                       struct user_namespace *user_ns, struct pid *pid);
+int ecryptfs_init_kthread(void);
+void ecryptfs_destroy_kthread(void);
+int ecryptfs_privileged_open(struct file **lower_file,
+                             struct dentry *lower_dentry,
+                             struct vfsmount *lower_mnt);
+int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry);
 
 #endif /* #ifndef ECRYPTFS_KERNEL_H */
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index 24749bf0668f..9244d653743e 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -192,6 +192,23 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
                                       | ECRYPTFS_ENCRYPTED);
         }
         mutex_unlock(&crypt_stat->cs_mutex);
+        if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_RDONLY)
+            && !(file->f_flags & O_RDONLY)) {
+                rc = -EPERM;
+                printk(KERN_WARNING "%s: Lower persistent file is RO; eCryptfs "
+                       "file must hence be opened RO\n", __func__);
+                goto out;
+        }
+        if (!ecryptfs_inode_to_private(inode)->lower_file) {
+                rc = ecryptfs_init_persistent_file(ecryptfs_dentry);
+                if (rc) {
+                        printk(KERN_ERR "%s: Error attempting to initialize "
+                               "the persistent file for the dentry with name "
+                               "[%s]; rc = [%d]\n", __func__,
+                               ecryptfs_dentry->d_name.name, rc);
+                        goto out;
+                }
+        }
         ecryptfs_set_file_lower(
                 file, ecryptfs_inode_to_private(inode)->lower_file);
         if (S_ISDIR(ecryptfs_dentry->d_inode->i_mode)) {
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index c92cc1c00aae..d755455e3bff 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -31,6 +31,7 @@
 #include <linux/mount.h>
 #include <linux/crypto.h>
 #include <linux/fs_stack.h>
+#include <asm/unaligned.h>
 #include "ecryptfs_kernel.h"
 
 static struct dentry *lock_parent(struct dentry *dentry)
@@ -188,6 +189,16 @@ static int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry)
                                 "context; rc = [%d]\n", rc);
                 goto out;
         }
+        if (!ecryptfs_inode_to_private(ecryptfs_dentry->d_inode)->lower_file) {
+                rc = ecryptfs_init_persistent_file(ecryptfs_dentry);
+                if (rc) {
+                        printk(KERN_ERR "%s: Error attempting to initialize "
+                               "the persistent file for the dentry with name "
+                               "[%s]; rc = [%d]\n", __func__,
+                               ecryptfs_dentry->d_name.name, rc);
+                        goto out;
+                }
+        }
         rc = ecryptfs_write_metadata(ecryptfs_dentry);
         if (rc) {
                 printk(KERN_ERR "Error writing headers; rc = [%d]\n", rc);
@@ -307,10 +318,11 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
                 d_add(dentry, NULL);
                 goto out;
         }
-        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 1);
+        rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb,
+                                ECRYPTFS_INTERPOSE_FLAG_D_ADD);
         if (rc) {
                 ecryptfs_printk(KERN_ERR, "Error interposing\n");
-                goto out_dput;
+                goto out;
         }
         if (S_ISDIR(lower_inode->i_mode)) {
                 ecryptfs_printk(KERN_DEBUG, "Is a directory; returning\n");
@@ -336,11 +348,21 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
                 rc = -ENOMEM;
                 ecryptfs_printk(KERN_ERR,
                                 "Cannot ecryptfs_kmalloc a page\n");
-                goto out_dput;
+                goto out;
         }
         crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
         if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED))
                 ecryptfs_set_default_sizes(crypt_stat);
+        if (!ecryptfs_inode_to_private(dentry->d_inode)->lower_file) {
+                rc = ecryptfs_init_persistent_file(dentry);
+                if (rc) {
+                        printk(KERN_ERR "%s: Error attempting to initialize "
+                               "the persistent file for the dentry with name "
+                               "[%s]; rc = [%d]\n", __func__,
+                               dentry->d_name.name, rc);
+                        goto out;
+                }
+        }
         rc = ecryptfs_read_and_validate_header_region(page_virt,
                                                       dentry->d_inode);
         if (rc) {
@@ -364,8 +386,7 @@ static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,
                 else
                         file_size = i_size_read(lower_dentry->d_inode);
         } else {
-                memcpy(&file_size, page_virt, sizeof(file_size));
-                file_size = be64_to_cpu(file_size);
+                file_size = get_unaligned_be64(page_virt);
         }
         i_size_write(dentry->d_inode, (loff_t)file_size);
         kmem_cache_free(ecryptfs_header_cache_2, page_virt);
diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index e82b457180be..f5b76a331b9c 100644
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -44,15 +44,15 @@ static int process_request_key_err(long err_code)
         int rc = 0;
 
         switch (err_code) {
-        case ENOKEY:
+        case -ENOKEY:
                 ecryptfs_printk(KERN_WARNING, "No key\n");
                 rc = -ENOENT;
                 break;
-        case EKEYEXPIRED:
+        case -EKEYEXPIRED:
                 ecryptfs_printk(KERN_WARNING, "Key expired\n");
                 rc = -ETIME;
                 break;
-        case EKEYREVOKED:
+        case -EKEYREVOKED:
                 ecryptfs_printk(KERN_WARNING, "Key revoked\n");
                 rc = -EINVAL;
                 break;
@@ -963,8 +963,7 @@ int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
         if (!(*auth_tok_key) || IS_ERR(*auth_tok_key)) {
                 printk(KERN_ERR "Could not find key with description: [%s]\n",
                        sig);
-                process_request_key_err(PTR_ERR(*auth_tok_key));
-                rc = -EINVAL;
+                rc = process_request_key_err(PTR_ERR(*auth_tok_key));
                 goto out;
         }
         (*auth_tok) = ecryptfs_get_key_payload_data(*auth_tok_key);
diff --git a/fs/ecryptfs/kthread.c b/fs/ecryptfs/kthread.c
new file mode 100644
index 000000000000..c440c6b58b2d
--- /dev/null
+++ b/fs/ecryptfs/kthread.c
@@ -0,0 +1,203 @@
+/**
+ * eCryptfs: Linux filesystem encryption layer
+ *
+ * Copyright (C) 2008 International Business Machines Corp.
+ *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <linux/kthread.h>
+#include <linux/freezer.h>
+#include <linux/wait.h>
+#include <linux/mount.h>
+#include "ecryptfs_kernel.h"
+
+struct kmem_cache *ecryptfs_open_req_cache;
+
+static struct ecryptfs_kthread_ctl {
+#define ECRYPTFS_KTHREAD_ZOMBIE 0x00000001
+        u32 flags;
+        struct mutex mux;
+        struct list_head req_list;
+        wait_queue_head_t wait;
+} ecryptfs_kthread_ctl;
+
+static struct task_struct *ecryptfs_kthread;
+
+/**
+ * ecryptfs_threadfn
+ * @ignored: ignored
+ *
+ * The eCryptfs kernel thread that has the responsibility of getting
+ * the lower persistent file with RW permissions.
+ *
+ * Returns zero on success; non-zero otherwise
+ */
+static int ecryptfs_threadfn(void *ignored)
+{
+        set_freezable();
+        while (1)  {
+                struct ecryptfs_open_req *req;
+
+                wait_event_freezable(
+                        ecryptfs_kthread_ctl.wait,
+                        (!list_empty(&ecryptfs_kthread_ctl.req_list)
+                         || kthread_should_stop()));
+                mutex_lock(&ecryptfs_kthread_ctl.mux);
+                if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
+                        mutex_unlock(&ecryptfs_kthread_ctl.mux);
+                        goto out;
+                }
+                while (!list_empty(&ecryptfs_kthread_ctl.req_list)) {
+                        req = list_first_entry(&ecryptfs_kthread_ctl.req_list,
+                                               struct ecryptfs_open_req,
+                                               kthread_ctl_list);
+                        mutex_lock(&req->mux);
+                        list_del(&req->kthread_ctl_list);
+                        if (!(req->flags & ECRYPTFS_REQ_ZOMBIE)) {
+                                dget(req->lower_dentry);
+                                mntget(req->lower_mnt);
+                                (*req->lower_file) = dentry_open(
+                                        req->lower_dentry, req->lower_mnt,
+                                        (O_RDWR | O_LARGEFILE));
+                                req->flags |= ECRYPTFS_REQ_PROCESSED;
+                        }
+                        wake_up(&req->wait);
+                        mutex_unlock(&req->mux);
+                }
+                mutex_unlock(&ecryptfs_kthread_ctl.mux);
+        }
+out:
+        return 0;
+}
+
+int ecryptfs_init_kthread(void)
+{
+        int rc = 0;
+
+        mutex_init(&ecryptfs_kthread_ctl.mux);
+        init_waitqueue_head(&ecryptfs_kthread_ctl.wait);
+        INIT_LIST_HEAD(&ecryptfs_kthread_ctl.req_list);
+        ecryptfs_kthread = kthread_run(&ecryptfs_threadfn, NULL,
+                                       "ecryptfs-kthread");
+        if (IS_ERR(ecryptfs_kthread)) {
+                rc = PTR_ERR(ecryptfs_kthread);
+                printk(KERN_ERR "%s: Failed to create kernel thread; rc = [%d]"
+                       "\n", __func__, rc);
+        }
+        return rc;
+}
+
+void ecryptfs_destroy_kthread(void)
+{
+        struct ecryptfs_open_req *req;
+
+        mutex_lock(&ecryptfs_kthread_ctl.mux);
+        ecryptfs_kthread_ctl.flags |= ECRYPTFS_KTHREAD_ZOMBIE;
+        list_for_each_entry(req, &ecryptfs_kthread_ctl.req_list,
+                            kthread_ctl_list) {
+                mutex_lock(&req->mux);
+                req->flags |= ECRYPTFS_REQ_ZOMBIE;
+                wake_up(&req->wait);
+                mutex_unlock(&req->mux);
+        }
+        mutex_unlock(&ecryptfs_kthread_ctl.mux);
+        kthread_stop(ecryptfs_kthread);
+        wake_up(&ecryptfs_kthread_ctl.wait);
+}
+
+/**
+ * ecryptfs_privileged_open
+ * @lower_file: Result of dentry_open by root on lower dentry
+ * @lower_dentry: Lower dentry for file to open
+ * @lower_mnt: Lower vfsmount for file to open
+ *
+ * This function gets a r/w file opened againt the lower dentry.
+ *
+ * Returns zero on success; non-zero otherwise
+ */
+int ecryptfs_privileged_open(struct file **lower_file,
+                             struct dentry *lower_dentry,
+                             struct vfsmount *lower_mnt)
+{
+        struct ecryptfs_open_req *req;
+        int rc = 0;
+
+        /* Corresponding dput() and mntput() are done when the
+         * persistent file is fput() when the eCryptfs inode is
+         * destroyed. */
+        dget(lower_dentry);
+        mntget(lower_mnt);
+        (*lower_file) = dentry_open(lower_dentry, lower_mnt,
+                                    (O_RDWR | O_LARGEFILE));
+        if (!IS_ERR(*lower_file))
+                goto out;
+        req = kmem_cache_alloc(ecryptfs_open_req_cache, GFP_KERNEL);
+        if (!req) {
+                rc = -ENOMEM;
+                goto out;
+        }
+        mutex_init(&req->mux);
+        req->lower_file = lower_file;
+        req->lower_dentry = lower_dentry;
+        req->lower_mnt = lower_mnt;
+        init_waitqueue_head(&req->wait);
+        req->flags = 0;
+        mutex_lock(&ecryptfs_kthread_ctl.mux);
+        if (ecryptfs_kthread_ctl.flags & ECRYPTFS_KTHREAD_ZOMBIE) {
+                rc = -EIO;
+                mutex_unlock(&ecryptfs_kthread_ctl.mux);
+                printk(KERN_ERR "%s: We are in the middle of shutting down; "
+                       "aborting privileged request to open lower file\n",
+                        __func__);
+                goto out_free;
+        }
+        list_add_tail(&req->kthread_ctl_list, &ecryptfs_kthread_ctl.req_list);
+        mutex_unlock(&ecryptfs_kthread_ctl.mux);
+        wake_up(&ecryptfs_kthread_ctl.wait);
+        wait_event(req->wait, (req->flags != 0));
+        mutex_lock(&req->mux);
+        BUG_ON(req->flags == 0);
+        if (req->flags & ECRYPTFS_REQ_DROPPED
+            || req->flags & ECRYPTFS_REQ_ZOMBIE) {
+                rc = -EIO;
+                printk(KERN_WARNING "%s: Privileged open request dropped\n",
+                       __func__);
+                goto out_unlock;
+        }
+        if (IS_ERR(*req->lower_file)) {
+                rc = PTR_ERR(*req->lower_file);
+                dget(lower_dentry);
+                mntget(lower_mnt);
+                (*lower_file) = dentry_open(lower_dentry, lower_mnt,
+                                            (O_RDONLY | O_LARGEFILE));
+                if (IS_ERR(*lower_file)) {
+                        rc = PTR_ERR(*req->lower_file);
+                        (*lower_file) = NULL;
+                        printk(KERN_WARNING "%s: Error attempting privileged "
+                               "open of lower file with either RW or RO "
+                               "perms; rc = [%d]. Giving up.\n",
+                               __func__, rc);
+                }
+        }
+out_unlock:
+        mutex_unlock(&req->mux);
+out_free:
+        kmem_cache_free(ecryptfs_open_req_cache, req);
+out:
+        return rc;
+}
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index d603631601eb..6f403cfba14f 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
  */
-static int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
+int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
 {
         struct ecryptfs_inode_info *inode_info =
                 ecryptfs_inode_to_private(ecryptfs_dentry->d_inode);
@@ -130,26 +130,12 @@ static int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
                         ecryptfs_dentry_to_lower_mnt(ecryptfs_dentry);
 
                 lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
-                /* Corresponding dput() and mntput() are done when the
-                 * persistent file is fput() when the eCryptfs inode
-                 * is destroyed. */
-                dget(lower_dentry);
-                mntget(lower_mnt);
-                inode_info->lower_file = dentry_open(lower_dentry,
-                                                     lower_mnt,
-                                                     (O_RDWR | O_LARGEFILE));
-                if (IS_ERR(inode_info->lower_file)) {
-                        dget(lower_dentry);
-                        mntget(lower_mnt);
-                        inode_info->lower_file = dentry_open(lower_dentry,
-                                                             lower_mnt,
-                                                             (O_RDONLY
-                                                              | O_LARGEFILE));
-                }
-                if (IS_ERR(inode_info->lower_file)) {
+                rc = ecryptfs_privileged_open(&inode_info->lower_file,
+                                                     lower_dentry, lower_mnt);
+                if (rc || IS_ERR(inode_info->lower_file)) {
                         printk(KERN_ERR "Error opening lower persistent file "
-                               "for lower_dentry [0x%p] and lower_mnt [0x%p]\n",
-                               lower_dentry, lower_mnt);
+                               "for lower_dentry [0x%p] and lower_mnt [0x%p]; "
+                               "rc = [%d]\n", lower_dentry, lower_mnt, rc);
                         rc = PTR_ERR(inode_info->lower_file);
                         inode_info->lower_file = NULL;
                 }
@@ -163,14 +149,14 @@ static int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
  * @lower_dentry: Existing dentry in the lower filesystem
  * @dentry: ecryptfs' dentry
  * @sb: ecryptfs's super_block
- * @flag: If set to true, then d_add is called, else d_instantiate is called
+ * @flags: flags to govern behavior of interpose procedure
  *
  * Interposes upper and lower dentries.
  *
  * Returns zero on success; non-zero otherwise
  */
 int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry,
-                       struct super_block *sb, int flag)
+                       struct super_block *sb, u32 flags)
 {
         struct inode *lower_inode;
         struct inode *inode;
@@ -207,7 +193,7 @@ int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry,
                 init_special_inode(inode, lower_inode->i_mode,
                                    lower_inode->i_rdev);
         dentry->d_op = &ecryptfs_dops;
-        if (flag)
+        if (flags & ECRYPTFS_INTERPOSE_FLAG_D_ADD)
                 d_add(dentry, inode);
         else
                 d_instantiate(dentry, inode);
@@ -215,13 +201,6 @@ int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry,
         /* This size will be overwritten for real files w/ headers and
          * other metadata */
         fsstack_copy_inode_size(inode, lower_inode);
-        rc = ecryptfs_init_persistent_file(dentry);
-        if (rc) {
-                printk(KERN_ERR "%s: Error attempting to initialize the "
-                       "persistent file for the dentry with name [%s]; "
-                       "rc = [%d]\n", __func__, dentry->d_name.name, rc);
-                goto out;
-        }
 out:
         return rc;
 }
@@ -262,10 +241,11 @@ static int ecryptfs_init_global_auth_toks(
                                "session keyring for sig specified in mount "
                                "option: [%s]\n", global_auth_tok->sig);
                         global_auth_tok->flags |= ECRYPTFS_AUTH_TOK_INVALID;
-                        rc = 0;
+                        goto out;
                 } else
                         global_auth_tok->flags &= ~ECRYPTFS_AUTH_TOK_INVALID;
         }
+out:
         return rc;
 }
 
@@ -314,7 +294,6 @@ static int ecryptfs_parse_options(struct super_block *sb, char *options)
         char *cipher_name_dst;
         char *cipher_name_src;
         char *cipher_key_bytes_src;
-        int cipher_name_len;
 
         if (!options) {
                 rc = -EINVAL;
@@ -395,17 +374,12 @@ static int ecryptfs_parse_options(struct super_block *sb, char *options)
                 goto out;
         }
         if (!cipher_name_set) {
-                cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER);
-                if (unlikely(cipher_name_len
-                             >= ECRYPTFS_MAX_CIPHER_NAME_SIZE)) {
-                        rc = -EINVAL;
-                        BUG();
-                        goto out;
-                }
-                memcpy(mount_crypt_stat->global_default_cipher_name,
-                       ECRYPTFS_DEFAULT_CIPHER, cipher_name_len);
-                mount_crypt_stat->global_default_cipher_name[cipher_name_len]
-                    = '\0';
+                int cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER);
+
+                BUG_ON(cipher_name_len >= ECRYPTFS_MAX_CIPHER_NAME_SIZE);
+
+                strcpy(mount_crypt_stat->global_default_cipher_name,
+                       ECRYPTFS_DEFAULT_CIPHER);
         }
         if (!cipher_key_bytes_set) {
                 mount_crypt_stat->global_default_cipher_key_size = 0;
@@ -430,7 +404,6 @@ static int ecryptfs_parse_options(struct super_block *sb, char *options)
                 printk(KERN_WARNING "One or more global auth toks could not "
                        "properly register; rc = [%d]\n", rc);
         }
-        rc = 0;
 out:
         return rc;
 }
@@ -679,6 +652,11 @@ static struct ecryptfs_cache_info {
                 .name = "ecryptfs_key_tfm_cache",
                 .size = sizeof(struct ecryptfs_key_tfm),
         },
+        {
+                .cache = &ecryptfs_open_req_cache,
+                .name = "ecryptfs_open_req_cache",
+                .size = sizeof(struct ecryptfs_open_req),
+        },
 };
 
 static void ecryptfs_free_kmem_caches(void)
@@ -795,11 +773,17 @@ static int __init ecryptfs_init(void)
                 printk(KERN_ERR "sysfs registration failed\n");
                 goto out_unregister_filesystem;
         }
+        rc = ecryptfs_init_kthread();
+        if (rc) {
+                printk(KERN_ERR "%s: kthread initialization failed; "
+                       "rc = [%d]\n", __func__, rc);
+                goto out_do_sysfs_unregistration;
+        }
         rc = ecryptfs_init_messaging(ecryptfs_transport);
         if (rc) {
-                ecryptfs_printk(KERN_ERR, "Failure occured while attempting to "
+                printk(KERN_ERR "Failure occured while attempting to "
                                 "initialize the eCryptfs netlink socket\n");
-                goto out_do_sysfs_unregistration;
+                goto out_destroy_kthread;
         }
         rc = ecryptfs_init_crypto();
         if (rc) {
@@ -814,6 +798,8 @@ static int __init ecryptfs_init(void)
         goto out;
 out_release_messaging:
         ecryptfs_release_messaging(ecryptfs_transport);
+out_destroy_kthread:
+        ecryptfs_destroy_kthread();
 out_do_sysfs_unregistration:
         do_sysfs_unregistration();
 out_unregister_filesystem:
@@ -833,6 +819,7 @@ static void __exit ecryptfs_exit(void)
                 printk(KERN_ERR "Failure whilst attempting to destroy crypto; "
                        "rc = [%d]\n", rc);
         ecryptfs_release_messaging(ecryptfs_transport);
+        ecryptfs_destroy_kthread();
         do_sysfs_unregistration();
         unregister_filesystem(&ecryptfs_fs_type);
         ecryptfs_free_kmem_caches();
diff --git a/fs/ecryptfs/miscdev.c b/fs/ecryptfs/miscdev.c
index 09a4522f65e6..b484792a0996 100644
--- a/fs/ecryptfs/miscdev.c
+++ b/fs/ecryptfs/miscdev.c
@@ -358,46 +358,6 @@ out_unlock_daemon:
 }
 
 /**
- * ecryptfs_miscdev_helo
- * @euid: effective user id of miscdevess sending helo packet
- * @user_ns: The namespace in which @euid applies
- * @pid: miscdevess id of miscdevess sending helo packet
- *
- * Returns zero on success; non-zero otherwise
- */
-static int ecryptfs_miscdev_helo(uid_t euid, struct user_namespace *user_ns,
-                                 struct pid *pid)
-{
-        int rc;
-
-        rc = ecryptfs_process_helo(ECRYPTFS_TRANSPORT_MISCDEV, euid, user_ns,
-                                   pid);
-        if (rc)
-                printk(KERN_WARNING "Error processing HELO; rc = [%d]\n", rc);
-        return rc;
-}
-
-/**
- * ecryptfs_miscdev_quit
- * @euid: effective user id of miscdevess sending quit packet
- * @user_ns: The namespace in which @euid applies
- * @pid: miscdevess id of miscdevess sending quit packet
- *
- * Returns zero on success; non-zero otherwise
- */
-static int ecryptfs_miscdev_quit(uid_t euid, struct user_namespace *user_ns,
-                                 struct pid *pid)
-{
-        int rc;
-
-        rc = ecryptfs_process_quit(euid, user_ns, pid);
-        if (rc)
-                printk(KERN_WARNING
-                       "Error processing QUIT message; rc = [%d]\n", rc);
-        return rc;
-}
-
-/**
  * ecryptfs_miscdev_response - miscdevess response to message previously sent to daemon
  * @data: Bytes comprising struct ecryptfs_message
  * @data_size: sizeof(struct ecryptfs_message) + data len
@@ -512,26 +472,7 @@ ecryptfs_miscdev_write(struct file *file, const char __user *buf,
                                __func__, rc);
                 break;
         case ECRYPTFS_MSG_HELO:
-                rc = ecryptfs_miscdev_helo(current->euid,
-                                           current->nsproxy->user_ns,
-                                           task_pid(current));
-                if (rc) {
-                        printk(KERN_ERR "%s: Error attempting to process "
-                               "helo from pid [0x%p]; rc = [%d]\n", __func__,
-                               task_pid(current), rc);
-                        goto out_free;
-                }
-                break;
         case ECRYPTFS_MSG_QUIT:
-                rc = ecryptfs_miscdev_quit(current->euid,
-                                           current->nsproxy->user_ns,
-                                           task_pid(current));
-                if (rc) {
-                        printk(KERN_ERR "%s: Error attempting to process "
-                               "quit from pid [0x%p]; rc = [%d]\n", __func__,
-                               task_pid(current), rc);
-                        goto out_free;
-                }
                 break;
         default:
                 ecryptfs_printk(KERN_WARNING, "Dropping miscdev "
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 2b6fe1e6e8ba..245c2dc02d5c 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -32,6 +32,7 @@
 #include <linux/file.h>
 #include <linux/crypto.h>
 #include <linux/scatterlist.h>
+#include <asm/unaligned.h>
 #include "ecryptfs_kernel.h"
 
 /**
@@ -372,7 +373,6 @@ out:
  */
 static int ecryptfs_write_inode_size_to_header(struct inode *ecryptfs_inode)
 {
-        u64 file_size;
         char *file_size_virt;
         int rc;
 
@@ -381,9 +381,7 @@ static int ecryptfs_write_inode_size_to_header(struct inode *ecryptfs_inode)
                 rc = -ENOMEM;
                 goto out;
         }
-        file_size = (u64)i_size_read(ecryptfs_inode);
-        file_size = cpu_to_be64(file_size);
-        memcpy(file_size_virt, &file_size, sizeof(u64));
+        put_unaligned_be64(i_size_read(ecryptfs_inode), file_size_virt);
         rc = ecryptfs_write_lower(ecryptfs_inode, file_size_virt, 0,
                                   sizeof(u64));
         kfree(file_size_virt);
@@ -403,7 +401,6 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
         struct dentry *lower_dentry =
                 ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_dentry;
         struct inode *lower_inode = lower_dentry->d_inode;
-        u64 file_size;
         int rc;
 
         if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) {
@@ -424,9 +421,7 @@ static int ecryptfs_write_inode_size_to_xattr(struct inode *ecryptfs_inode)
                                            xattr_virt, PAGE_CACHE_SIZE);
         if (size < 0)
                 size = 8;
-        file_size = (u64)i_size_read(ecryptfs_inode);
-        file_size = cpu_to_be64(file_size);
-        memcpy(xattr_virt, &file_size, sizeof(u64));
+        put_unaligned_be64(i_size_read(ecryptfs_inode), xattr_virt);
         rc = lower_inode->i_op->setxattr(lower_dentry, ECRYPTFS_XATTR_NAME,
                                          xattr_virt, size, 0);
         mutex_unlock(&lower_inode->i_mutex);