Patched in Tegra support.

1 files changed, 57 insertions, 52 deletions

diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index d45ba456812..d3f95f941c4 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -48,7 +48,8 @@ static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,
                                 unsigned long nr_segs, loff_t pos)
 {
         ssize_t rc;
-        struct path lower;
+        struct dentry *lower_dentry;
+        struct vfsmount *lower_vfsmount;
         struct file *file = iocb->ki_filp;
 
         rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
@@ -59,9 +60,9 @@ static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,
         if (-EIOCBQUEUED == rc)
                 rc = wait_on_sync_kiocb(iocb);
         if (rc >= 0) {
-                lower.dentry = ecryptfs_dentry_to_lower(file->f_path.dentry);
-                lower.mnt = ecryptfs_dentry_to_lower_mnt(file->f_path.dentry);
-                touch_atime(&lower);
+                lower_dentry = ecryptfs_dentry_to_lower(file->f_path.dentry);
+                lower_vfsmount = ecryptfs_dentry_to_lower_mnt(file->f_path.dentry);
+                touch_atime(lower_vfsmount, lower_dentry);
         }
         return rc;
 }
@@ -138,50 +139,29 @@ out:
         return rc;
 }
 
-struct kmem_cache *ecryptfs_file_info_cache;
-
-static int read_or_initialize_metadata(struct dentry *dentry)
+static void ecryptfs_vma_close(struct vm_area_struct *vma)
 {
-        struct inode *inode = dentry->d_inode;
-        struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
-        struct ecryptfs_crypt_stat *crypt_stat;
-        int rc;
+        filemap_write_and_wait(vma->vm_file->f_mapping);
+}
 
-        crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
-        mount_crypt_stat = &ecryptfs_superblock_to_private(
-                                                inode->i_sb)->mount_crypt_stat;
-        mutex_lock(&crypt_stat->cs_mutex);
+static const struct vm_operations_struct ecryptfs_file_vm_ops = {
+        .close          = ecryptfs_vma_close,
+        .fault          = filemap_fault,
+};
 
-        if (crypt_stat->flags & ECRYPTFS_POLICY_APPLIED &&
-            crypt_stat->flags & ECRYPTFS_KEY_VALID) {
-                rc = 0;
-                goto out;
-        }
+static int ecryptfs_file_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        int rc;
 
-        rc = ecryptfs_read_metadata(dentry);
+        rc = generic_file_mmap(file, vma);
         if (!rc)
-                goto out;
+                vma->vm_ops = &ecryptfs_file_vm_ops;
 
-        if (mount_crypt_stat->flags & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED) {
-                crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
-                                       | ECRYPTFS_ENCRYPTED);
-                rc = 0;
-                goto out;
-        }
-
-        if (!(mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED) &&
-            !i_size_read(ecryptfs_inode_to_lower(inode))) {
-                rc = ecryptfs_initialize_file(dentry, inode);
-                if (!rc)
-                        goto out;
-        }
-
-        rc = -EIO;
-out:
-        mutex_unlock(&crypt_stat->cs_mutex);
         return rc;
 }
 
+struct kmem_cache *ecryptfs_file_info_cache;
+
 /**
  * ecryptfs_open
  * @inode: inode speciying file to open
@@ -257,9 +237,32 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
                 rc = 0;
                 goto out;
         }
-        rc = read_or_initialize_metadata(ecryptfs_dentry);
-        if (rc)
-                goto out_put;
+        mutex_lock(&crypt_stat->cs_mutex);
+        if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)
+            || !(crypt_stat->flags & ECRYPTFS_KEY_VALID)) {
+                rc = ecryptfs_read_metadata(ecryptfs_dentry);
+                if (rc) {
+                        ecryptfs_printk(KERN_DEBUG,
+                                        "Valid headers not found\n");
+                        if (!(mount_crypt_stat->flags
+                              & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) {
+                                rc = -EIO;
+                                printk(KERN_WARNING "Either the lower file "
+                                       "is not in a valid eCryptfs format, "
+                                       "or the key could not be retrieved. "
+                                       "Plaintext passthrough mode is not "
+                                       "enabled; returning -EIO\n");
+                                mutex_unlock(&crypt_stat->cs_mutex);
+                                goto out_put;
+                        }
+                        rc = 0;
+                        crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
+                                               | ECRYPTFS_ENCRYPTED);
+                        mutex_unlock(&crypt_stat->cs_mutex);
+                        goto out;
+                }
+        }
+        mutex_unlock(&crypt_stat->cs_mutex);
         ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = "
                         "[0x%.16lx] size: [0x%.16llx]\n", inode, inode->i_ino,
                         (unsigned long long)i_size_read(inode));
@@ -275,14 +278,8 @@ out:
 
 static int ecryptfs_flush(struct file *file, fl_owner_t td)
 {
-        struct file *lower_file = ecryptfs_file_to_lower(file);
-
-        if (lower_file->f_op && lower_file->f_op->flush) {
-                filemap_write_and_wait(file->f_mapping);
-                return lower_file->f_op->flush(lower_file, td);
-        }
-
-        return 0;
+        return file->f_mode & FMODE_WRITE
+               ? filemap_write_and_wait(file->f_mapping) : 0;
 }
 
 static int ecryptfs_release(struct inode *inode, struct file *file)
@@ -296,7 +293,15 @@ static int ecryptfs_release(struct inode *inode, struct file *file)
 static int
 ecryptfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
-        return vfs_fsync(ecryptfs_file_to_lower(file), datasync);
+        int rc = 0;
+
+        rc = generic_file_fsync(file, start, end, datasync);
+        if (rc)
+                goto out;
+        rc = vfs_fsync_range(ecryptfs_file_to_lower(file), start, end,
+                             datasync);
+out:
+        return rc;
 }
 
 static int ecryptfs_fasync(int fd, struct file *file, int flag)
@@ -365,7 +370,7 @@ const struct file_operations ecryptfs_main_fops = {
 #ifdef CONFIG_COMPAT
         .compat_ioctl = ecryptfs_compat_ioctl,
 #endif
-        .mmap = generic_file_mmap,
+        .mmap = ecryptfs_file_mmap,
         .open = ecryptfs_open,
         .flush = ecryptfs_flush,
         .release = ecryptfs_release,