1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * eCryptfs: Linux filesystem encryption layer
  4 *
  5 * Copyright (C) 1997-2004 Erez Zadok
  6 * Copyright (C) 2001-2004 Stony Brook University
  7 * Copyright (C) 2004-2007 International Business Machines Corp.
  8 *   Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
  9 *   		Michael C. Thompson <mcthomps@us.ibm.com>
 10 */
 11
 12#include <linux/file.h>
 13#include <linux/poll.h>
 14#include <linux/slab.h>
 15#include <linux/mount.h>
 16#include <linux/pagemap.h>
 17#include <linux/security.h>
 18#include <linux/compat.h>
 19#include <linux/fs_stack.h>
 20#include "ecryptfs_kernel.h"
 21
 22/*
 23 * ecryptfs_read_update_atime
 24 *
 25 * generic_file_read updates the atime of upper layer inode.  But, it
 26 * doesn't give us a chance to update the atime of the lower layer
 27 * inode.  This function is a wrapper to generic_file_read.  It
 28 * updates the atime of the lower level inode if generic_file_read
 29 * returns without any errors. This is to be used only for file reads.
 30 * The function to be used for directory reads is ecryptfs_read.
 31 */
 32static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,
 33				struct iov_iter *to)
 34{
 35	ssize_t rc;
 36	struct path *path;
 37	struct file *file = iocb->ki_filp;
 38
 39	rc = generic_file_read_iter(iocb, to);
 40	if (rc >= 0) {
 41		path = ecryptfs_dentry_to_lower_path(file->f_path.dentry);
 42		touch_atime(path);
 43	}
 44	return rc;
 45}
 46
 47struct ecryptfs_getdents_callback {
 48	struct dir_context ctx;
 49	struct dir_context *caller;
 50	struct super_block *sb;
 51	int filldir_called;
 52	int entries_written;
 53};
 54
 55/* Inspired by generic filldir in fs/readdir.c */
 56static int
 57ecryptfs_filldir(struct dir_context *ctx, const char *lower_name,
 58		 int lower_namelen, loff_t offset, u64 ino, unsigned int d_type)
 59{
 60	struct ecryptfs_getdents_callback *buf =
 61		container_of(ctx, struct ecryptfs_getdents_callback, ctx);
 62	size_t name_size;
 63	char *name;
 64	int rc;
 
 65
 66	buf->filldir_called++;
 67	rc = ecryptfs_decode_and_decrypt_filename(&name, &name_size,
 68						  buf->sb, lower_name,
 69						  lower_namelen);
 70	if (rc) {
 71		if (rc != -EINVAL) {
 72			ecryptfs_printk(KERN_DEBUG,
 73					"%s: Error attempting to decode and decrypt filename [%s]; rc = [%d]\n",
 74					__func__, lower_name, rc);
 75			return rc;
 76		}
 77
 78		/* Mask -EINVAL errors as these are most likely due a plaintext
 79		 * filename present in the lower filesystem despite filename
 80		 * encryption being enabled. One unavoidable example would be
 81		 * the "lost+found" dentry in the root directory of an Ext4
 82		 * filesystem.
 83		 */
 84		return 0;
 85	}
 86
 87	buf->caller->pos = buf->ctx.pos;
 88	rc = !dir_emit(buf->caller, name, name_size, ino, d_type);
 89	kfree(name);
 90	if (!rc)
 91		buf->entries_written++;
 92
 93	return rc;
 94}
 95
 96/**
 97 * ecryptfs_readdir
 98 * @file: The eCryptfs directory file
 99 * @ctx: The actor to feed the entries to
100 */
101static int ecryptfs_readdir(struct file *file, struct dir_context *ctx)
102{
103	int rc;
104	struct file *lower_file;
105	struct inode *inode = file_inode(file);
106	struct ecryptfs_getdents_callback buf = {
107		.ctx.actor = ecryptfs_filldir,
108		.caller = ctx,
109		.sb = inode->i_sb,
110	};
111	lower_file = ecryptfs_file_to_lower(file);
112	rc = iterate_dir(lower_file, &buf.ctx);
113	ctx->pos = buf.ctx.pos;
114	if (rc < 0)
115		goto out;
116	if (buf.filldir_called && !buf.entries_written)
117		goto out;
118	if (rc >= 0)
119		fsstack_copy_attr_atime(inode,
120					file_inode(lower_file));
121out:
122	return rc;
123}
124
125struct kmem_cache *ecryptfs_file_info_cache;
126
127static int read_or_initialize_metadata(struct dentry *dentry)
128{
129	struct inode *inode = d_inode(dentry);
130	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
131	struct ecryptfs_crypt_stat *crypt_stat;
132	int rc;
133
134	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
135	mount_crypt_stat = &ecryptfs_superblock_to_private(
136						inode->i_sb)->mount_crypt_stat;
137	mutex_lock(&crypt_stat->cs_mutex);
138
139	if (crypt_stat->flags & ECRYPTFS_POLICY_APPLIED &&
140	    crypt_stat->flags & ECRYPTFS_KEY_VALID) {
141		rc = 0;
142		goto out;
143	}
144
145	rc = ecryptfs_read_metadata(dentry);
146	if (!rc)
147		goto out;
148
149	if (mount_crypt_stat->flags & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED) {
150		crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
151				       | ECRYPTFS_ENCRYPTED);
152		rc = 0;
153		goto out;
154	}
155
156	if (!(mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED) &&
157	    !i_size_read(ecryptfs_inode_to_lower(inode))) {
158		rc = ecryptfs_initialize_file(dentry, inode);
159		if (!rc)
160			goto out;
161	}
162
163	rc = -EIO;
164out:
165	mutex_unlock(&crypt_stat->cs_mutex);
166	return rc;
167}
168
169static int ecryptfs_mmap(struct file *file, struct vm_area_struct *vma)
170{
171	struct file *lower_file = ecryptfs_file_to_lower(file);
172	/*
173	 * Don't allow mmap on top of file systems that don't support it
174	 * natively.  If FILESYSTEM_MAX_STACK_DEPTH > 2 or ecryptfs
175	 * allows recursive mounting, this will need to be extended.
176	 */
177	if (!lower_file->f_op->mmap)
178		return -ENODEV;
179	return generic_file_mmap(file, vma);
180}
181
182/**
183 * ecryptfs_open
184 * @inode: inode specifying file to open
185 * @file: Structure to return filled in
186 *
187 * Opens the file specified by inode.
188 *
189 * Returns zero on success; non-zero otherwise
190 */
191static int ecryptfs_open(struct inode *inode, struct file *file)
192{
193	int rc = 0;
194	struct ecryptfs_crypt_stat *crypt_stat = NULL;
195	struct dentry *ecryptfs_dentry = file->f_path.dentry;
196	/* Private value of ecryptfs_dentry allocated in
197	 * ecryptfs_lookup() */
198	struct ecryptfs_file_info *file_info;
199
200	/* Released in ecryptfs_release or end of function if failure */
201	file_info = kmem_cache_zalloc(ecryptfs_file_info_cache, GFP_KERNEL);
202	ecryptfs_set_file_private(file, file_info);
203	if (!file_info) {
204		ecryptfs_printk(KERN_ERR,
205				"Error attempting to allocate memory\n");
206		rc = -ENOMEM;
207		goto out;
208	}
209	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
210	mutex_lock(&crypt_stat->cs_mutex);
211	if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)) {
212		ecryptfs_printk(KERN_DEBUG, "Setting flags for stat...\n");
213		/* Policy code enabled in future release */
214		crypt_stat->flags |= (ECRYPTFS_POLICY_APPLIED
215				      | ECRYPTFS_ENCRYPTED);
216	}
217	mutex_unlock(&crypt_stat->cs_mutex);
218	rc = ecryptfs_get_lower_file(ecryptfs_dentry, inode);
219	if (rc) {
220		printk(KERN_ERR "%s: Error attempting to initialize "
221			"the lower file for the dentry with name "
222			"[%pd]; rc = [%d]\n", __func__,
223			ecryptfs_dentry, rc);
224		goto out_free;
225	}
226	if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_ACCMODE)
227	    == O_RDONLY && (file->f_flags & O_ACCMODE) != O_RDONLY) {
228		rc = -EPERM;
229		printk(KERN_WARNING "%s: Lower file is RO; eCryptfs "
230		       "file must hence be opened RO\n", __func__);
231		goto out_put;
232	}
233	ecryptfs_set_file_lower(
234		file, ecryptfs_inode_to_private(inode)->lower_file);
235	rc = read_or_initialize_metadata(ecryptfs_dentry);
236	if (rc)
237		goto out_put;
238	ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = "
239			"[0x%.16lx] size: [0x%.16llx]\n", inode, inode->i_ino,
240			(unsigned long long)i_size_read(inode));
241	goto out;
242out_put:
243	ecryptfs_put_lower_file(inode);
244out_free:
245	kmem_cache_free(ecryptfs_file_info_cache,
246			ecryptfs_file_to_private(file));
247out:
248	return rc;
249}
250
251/**
252 * ecryptfs_dir_open
253 * @inode: inode specifying file to open
254 * @file: Structure to return filled in
255 *
256 * Opens the file specified by inode.
257 *
258 * Returns zero on success; non-zero otherwise
259 */
260static int ecryptfs_dir_open(struct inode *inode, struct file *file)
261{
262	struct dentry *ecryptfs_dentry = file->f_path.dentry;
263	/* Private value of ecryptfs_dentry allocated in
264	 * ecryptfs_lookup() */
265	struct ecryptfs_file_info *file_info;
266	struct file *lower_file;
267
268	/* Released in ecryptfs_release or end of function if failure */
269	file_info = kmem_cache_zalloc(ecryptfs_file_info_cache, GFP_KERNEL);
270	ecryptfs_set_file_private(file, file_info);
271	if (unlikely(!file_info)) {
272		ecryptfs_printk(KERN_ERR,
273				"Error attempting to allocate memory\n");
274		return -ENOMEM;
275	}
276	lower_file = dentry_open(ecryptfs_dentry_to_lower_path(ecryptfs_dentry),
277				 file->f_flags, current_cred());
278	if (IS_ERR(lower_file)) {
279		printk(KERN_ERR "%s: Error attempting to initialize "
280			"the lower file for the dentry with name "
281			"[%pd]; rc = [%ld]\n", __func__,
282			ecryptfs_dentry, PTR_ERR(lower_file));
283		kmem_cache_free(ecryptfs_file_info_cache, file_info);
284		return PTR_ERR(lower_file);
285	}
286	ecryptfs_set_file_lower(file, lower_file);
287	return 0;
288}
289
290static int ecryptfs_flush(struct file *file, fl_owner_t td)
291{
292	struct file *lower_file = ecryptfs_file_to_lower(file);
293
294	if (lower_file->f_op->flush) {
295		filemap_write_and_wait(file->f_mapping);
296		return lower_file->f_op->flush(lower_file, td);
297	}
298
299	return 0;
300}
301
302static int ecryptfs_release(struct inode *inode, struct file *file)
303{
304	ecryptfs_put_lower_file(inode);
305	kmem_cache_free(ecryptfs_file_info_cache,
306			ecryptfs_file_to_private(file));
307	return 0;
308}
309
310static int ecryptfs_dir_release(struct inode *inode, struct file *file)
311{
312	fput(ecryptfs_file_to_lower(file));
313	kmem_cache_free(ecryptfs_file_info_cache,
314			ecryptfs_file_to_private(file));
315	return 0;
316}
317
318static loff_t ecryptfs_dir_llseek(struct file *file, loff_t offset, int whence)
319{
320	return vfs_llseek(ecryptfs_file_to_lower(file), offset, whence);
321}
322
323static int
324ecryptfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
325{
326	int rc;
327
328	rc = file_write_and_wait(file);
329	if (rc)
330		return rc;
331
332	return vfs_fsync(ecryptfs_file_to_lower(file), datasync);
333}
334
335static int ecryptfs_fasync(int fd, struct file *file, int flag)
336{
337	int rc = 0;
338	struct file *lower_file = NULL;
339
340	lower_file = ecryptfs_file_to_lower(file);
341	if (lower_file->f_op->fasync)
342		rc = lower_file->f_op->fasync(fd, lower_file, flag);
343	return rc;
344}
345
346static long
347ecryptfs_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
348{
349	struct file *lower_file = ecryptfs_file_to_lower(file);
350	long rc = -ENOTTY;
351
352	if (!lower_file->f_op->unlocked_ioctl)
353		return rc;
354
355	switch (cmd) {
356	case FITRIM:
357	case FS_IOC_GETFLAGS:
358	case FS_IOC_SETFLAGS:
359	case FS_IOC_GETVERSION:
360	case FS_IOC_SETVERSION:
361		rc = lower_file->f_op->unlocked_ioctl(lower_file, cmd, arg);
362		fsstack_copy_attr_all(file_inode(file), file_inode(lower_file));
363
364		return rc;
365	default:
366		return rc;
367	}
368}
369
370#ifdef CONFIG_COMPAT
371static long
372ecryptfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
373{
374	struct file *lower_file = ecryptfs_file_to_lower(file);
375	long rc = -ENOIOCTLCMD;
376
377	if (!lower_file->f_op->compat_ioctl)
378		return rc;
379
380	switch (cmd) {
381	case FITRIM:
382	case FS_IOC32_GETFLAGS:
383	case FS_IOC32_SETFLAGS:
384	case FS_IOC32_GETVERSION:
385	case FS_IOC32_SETVERSION:
386		rc = lower_file->f_op->compat_ioctl(lower_file, cmd, arg);
387		fsstack_copy_attr_all(file_inode(file), file_inode(lower_file));
388
389		return rc;
390	default:
391		return rc;
392	}
393}
394#endif
395
396const struct file_operations ecryptfs_dir_fops = {
397	.iterate_shared = ecryptfs_readdir,
398	.read = generic_read_dir,
399	.unlocked_ioctl = ecryptfs_unlocked_ioctl,
400#ifdef CONFIG_COMPAT
401	.compat_ioctl = ecryptfs_compat_ioctl,
402#endif
403	.open = ecryptfs_dir_open,
404	.release = ecryptfs_dir_release,
405	.fsync = ecryptfs_fsync,
406	.llseek = ecryptfs_dir_llseek,
407};
408
409const struct file_operations ecryptfs_main_fops = {
410	.llseek = generic_file_llseek,
411	.read_iter = ecryptfs_read_update_atime,
412	.write_iter = generic_file_write_iter,
413	.unlocked_ioctl = ecryptfs_unlocked_ioctl,
414#ifdef CONFIG_COMPAT
415	.compat_ioctl = ecryptfs_compat_ioctl,
416#endif
417	.mmap = ecryptfs_mmap,
418	.open = ecryptfs_open,
419	.flush = ecryptfs_flush,
420	.release = ecryptfs_release,
421	.fsync = ecryptfs_fsync,
422	.fasync = ecryptfs_fasync,
423	.splice_read = generic_file_splice_read,
424};

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * eCryptfs: Linux filesystem encryption layer
  4 *
  5 * Copyright (C) 1997-2004 Erez Zadok
  6 * Copyright (C) 2001-2004 Stony Brook University
  7 * Copyright (C) 2004-2007 International Business Machines Corp.
  8 *   Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
  9 *   		Michael C. Thompson <mcthomps@us.ibm.com>
 10 */
 11
 12#include <linux/file.h>
 13#include <linux/poll.h>
 14#include <linux/slab.h>
 15#include <linux/mount.h>
 16#include <linux/pagemap.h>
 17#include <linux/security.h>
 18#include <linux/compat.h>
 19#include <linux/fs_stack.h>
 20#include "ecryptfs_kernel.h"
 21
 22/*
 23 * ecryptfs_read_update_atime
 24 *
 25 * generic_file_read updates the atime of upper layer inode.  But, it
 26 * doesn't give us a chance to update the atime of the lower layer
 27 * inode.  This function is a wrapper to generic_file_read.  It
 28 * updates the atime of the lower level inode if generic_file_read
 29 * returns without any errors. This is to be used only for file reads.
 30 * The function to be used for directory reads is ecryptfs_read.
 31 */
 32static ssize_t ecryptfs_read_update_atime(struct kiocb *iocb,
 33				struct iov_iter *to)
 34{
 35	ssize_t rc;
 36	const struct path *path;
 37	struct file *file = iocb->ki_filp;
 38
 39	rc = generic_file_read_iter(iocb, to);
 40	if (rc >= 0) {
 41		path = ecryptfs_dentry_to_lower_path(file->f_path.dentry);
 42		touch_atime(path);
 43	}
 44	return rc;
 45}
 46
 47struct ecryptfs_getdents_callback {
 48	struct dir_context ctx;
 49	struct dir_context *caller;
 50	struct super_block *sb;
 51	int filldir_called;
 52	int entries_written;
 53};
 54
 55/* Inspired by generic filldir in fs/readdir.c */
 56static bool
 57ecryptfs_filldir(struct dir_context *ctx, const char *lower_name,
 58		 int lower_namelen, loff_t offset, u64 ino, unsigned int d_type)
 59{
 60	struct ecryptfs_getdents_callback *buf =
 61		container_of(ctx, struct ecryptfs_getdents_callback, ctx);
 62	size_t name_size;
 63	char *name;
 64	int err;
 65	bool res;
 66
 67	buf->filldir_called++;
 68	err = ecryptfs_decode_and_decrypt_filename(&name, &name_size,
 69						   buf->sb, lower_name,
 70						   lower_namelen);
 71	if (err) {
 72		if (err != -EINVAL) {
 73			ecryptfs_printk(KERN_DEBUG,
 74					"%s: Error attempting to decode and decrypt filename [%s]; rc = [%d]\n",
 75					__func__, lower_name, err);
 76			return false;
 77		}
 78
 79		/* Mask -EINVAL errors as these are most likely due a plaintext
 80		 * filename present in the lower filesystem despite filename
 81		 * encryption being enabled. One unavoidable example would be
 82		 * the "lost+found" dentry in the root directory of an Ext4
 83		 * filesystem.
 84		 */
 85		return true;
 86	}
 87
 88	buf->caller->pos = buf->ctx.pos;
 89	res = dir_emit(buf->caller, name, name_size, ino, d_type);
 90	kfree(name);
 91	if (res)
 92		buf->entries_written++;
 93	return res;
 
 94}
 95
 96/**
 97 * ecryptfs_readdir
 98 * @file: The eCryptfs directory file
 99 * @ctx: The actor to feed the entries to
100 */
101static int ecryptfs_readdir(struct file *file, struct dir_context *ctx)
102{
103	int rc;
104	struct file *lower_file;
105	struct inode *inode = file_inode(file);
106	struct ecryptfs_getdents_callback buf = {
107		.ctx.actor = ecryptfs_filldir,
108		.caller = ctx,
109		.sb = inode->i_sb,
110	};
111	lower_file = ecryptfs_file_to_lower(file);
112	rc = iterate_dir(lower_file, &buf.ctx);
113	ctx->pos = buf.ctx.pos;
114	if (rc >= 0 && (buf.entries_written || !buf.filldir_called))
115		fsstack_copy_attr_atime(inode, file_inode(lower_file));
 
 
 
 
 
 
116	return rc;
117}
118
119struct kmem_cache *ecryptfs_file_info_cache;
120
121static int read_or_initialize_metadata(struct dentry *dentry)
122{
123	struct inode *inode = d_inode(dentry);
124	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
125	struct ecryptfs_crypt_stat *crypt_stat;
126	int rc;
127
128	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
129	mount_crypt_stat = &ecryptfs_superblock_to_private(
130						inode->i_sb)->mount_crypt_stat;
131	mutex_lock(&crypt_stat->cs_mutex);
132
133	if (crypt_stat->flags & ECRYPTFS_POLICY_APPLIED &&
134	    crypt_stat->flags & ECRYPTFS_KEY_VALID) {
135		rc = 0;
136		goto out;
137	}
138
139	rc = ecryptfs_read_metadata(dentry);
140	if (!rc)
141		goto out;
142
143	if (mount_crypt_stat->flags & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED) {
144		crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
145				       | ECRYPTFS_ENCRYPTED);
146		rc = 0;
147		goto out;
148	}
149
150	if (!(mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED) &&
151	    !i_size_read(ecryptfs_inode_to_lower(inode))) {
152		rc = ecryptfs_initialize_file(dentry, inode);
153		if (!rc)
154			goto out;
155	}
156
157	rc = -EIO;
158out:
159	mutex_unlock(&crypt_stat->cs_mutex);
160	return rc;
161}
162
163static int ecryptfs_mmap(struct file *file, struct vm_area_struct *vma)
164{
165	struct file *lower_file = ecryptfs_file_to_lower(file);
166	/*
167	 * Don't allow mmap on top of file systems that don't support it
168	 * natively.  If FILESYSTEM_MAX_STACK_DEPTH > 2 or ecryptfs
169	 * allows recursive mounting, this will need to be extended.
170	 */
171	if (!lower_file->f_op->mmap)
172		return -ENODEV;
173	return generic_file_mmap(file, vma);
174}
175
176/**
177 * ecryptfs_open
178 * @inode: inode specifying file to open
179 * @file: Structure to return filled in
180 *
181 * Opens the file specified by inode.
182 *
183 * Returns zero on success; non-zero otherwise
184 */
185static int ecryptfs_open(struct inode *inode, struct file *file)
186{
187	int rc = 0;
188	struct ecryptfs_crypt_stat *crypt_stat = NULL;
189	struct dentry *ecryptfs_dentry = file->f_path.dentry;
190	/* Private value of ecryptfs_dentry allocated in
191	 * ecryptfs_lookup() */
192	struct ecryptfs_file_info *file_info;
193
194	/* Released in ecryptfs_release or end of function if failure */
195	file_info = kmem_cache_zalloc(ecryptfs_file_info_cache, GFP_KERNEL);
196	ecryptfs_set_file_private(file, file_info);
197	if (!file_info) {
198		ecryptfs_printk(KERN_ERR,
199				"Error attempting to allocate memory\n");
200		rc = -ENOMEM;
201		goto out;
202	}
203	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
204	mutex_lock(&crypt_stat->cs_mutex);
205	if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)) {
206		ecryptfs_printk(KERN_DEBUG, "Setting flags for stat...\n");
207		/* Policy code enabled in future release */
208		crypt_stat->flags |= (ECRYPTFS_POLICY_APPLIED
209				      | ECRYPTFS_ENCRYPTED);
210	}
211	mutex_unlock(&crypt_stat->cs_mutex);
212	rc = ecryptfs_get_lower_file(ecryptfs_dentry, inode);
213	if (rc) {
214		printk(KERN_ERR "%s: Error attempting to initialize "
215			"the lower file for the dentry with name "
216			"[%pd]; rc = [%d]\n", __func__,
217			ecryptfs_dentry, rc);
218		goto out_free;
219	}
220	if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_ACCMODE)
221	    == O_RDONLY && (file->f_flags & O_ACCMODE) != O_RDONLY) {
222		rc = -EPERM;
223		printk(KERN_WARNING "%s: Lower file is RO; eCryptfs "
224		       "file must hence be opened RO\n", __func__);
225		goto out_put;
226	}
227	ecryptfs_set_file_lower(
228		file, ecryptfs_inode_to_private(inode)->lower_file);
229	rc = read_or_initialize_metadata(ecryptfs_dentry);
230	if (rc)
231		goto out_put;
232	ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = "
233			"[0x%.16lx] size: [0x%.16llx]\n", inode, inode->i_ino,
234			(unsigned long long)i_size_read(inode));
235	goto out;
236out_put:
237	ecryptfs_put_lower_file(inode);
238out_free:
239	kmem_cache_free(ecryptfs_file_info_cache,
240			ecryptfs_file_to_private(file));
241out:
242	return rc;
243}
244
245/**
246 * ecryptfs_dir_open
247 * @inode: inode specifying file to open
248 * @file: Structure to return filled in
249 *
250 * Opens the file specified by inode.
251 *
252 * Returns zero on success; non-zero otherwise
253 */
254static int ecryptfs_dir_open(struct inode *inode, struct file *file)
255{
256	struct dentry *ecryptfs_dentry = file->f_path.dentry;
257	/* Private value of ecryptfs_dentry allocated in
258	 * ecryptfs_lookup() */
259	struct ecryptfs_file_info *file_info;
260	struct file *lower_file;
261
262	/* Released in ecryptfs_release or end of function if failure */
263	file_info = kmem_cache_zalloc(ecryptfs_file_info_cache, GFP_KERNEL);
264	ecryptfs_set_file_private(file, file_info);
265	if (unlikely(!file_info)) {
266		ecryptfs_printk(KERN_ERR,
267				"Error attempting to allocate memory\n");
268		return -ENOMEM;
269	}
270	lower_file = dentry_open(ecryptfs_dentry_to_lower_path(ecryptfs_dentry),
271				 file->f_flags, current_cred());
272	if (IS_ERR(lower_file)) {
273		printk(KERN_ERR "%s: Error attempting to initialize "
274			"the lower file for the dentry with name "
275			"[%pd]; rc = [%ld]\n", __func__,
276			ecryptfs_dentry, PTR_ERR(lower_file));
277		kmem_cache_free(ecryptfs_file_info_cache, file_info);
278		return PTR_ERR(lower_file);
279	}
280	ecryptfs_set_file_lower(file, lower_file);
281	return 0;
282}
283
284static int ecryptfs_flush(struct file *file, fl_owner_t td)
285{
286	struct file *lower_file = ecryptfs_file_to_lower(file);
287
288	if (lower_file->f_op->flush) {
289		filemap_write_and_wait(file->f_mapping);
290		return lower_file->f_op->flush(lower_file, td);
291	}
292
293	return 0;
294}
295
296static int ecryptfs_release(struct inode *inode, struct file *file)
297{
298	ecryptfs_put_lower_file(inode);
299	kmem_cache_free(ecryptfs_file_info_cache,
300			ecryptfs_file_to_private(file));
301	return 0;
302}
303
304static int ecryptfs_dir_release(struct inode *inode, struct file *file)
305{
306	fput(ecryptfs_file_to_lower(file));
307	kmem_cache_free(ecryptfs_file_info_cache,
308			ecryptfs_file_to_private(file));
309	return 0;
310}
311
312static loff_t ecryptfs_dir_llseek(struct file *file, loff_t offset, int whence)
313{
314	return vfs_llseek(ecryptfs_file_to_lower(file), offset, whence);
315}
316
317static int
318ecryptfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
319{
320	int rc;
321
322	rc = file_write_and_wait(file);
323	if (rc)
324		return rc;
325
326	return vfs_fsync(ecryptfs_file_to_lower(file), datasync);
327}
328
329static int ecryptfs_fasync(int fd, struct file *file, int flag)
330{
331	int rc = 0;
332	struct file *lower_file = NULL;
333
334	lower_file = ecryptfs_file_to_lower(file);
335	if (lower_file->f_op->fasync)
336		rc = lower_file->f_op->fasync(fd, lower_file, flag);
337	return rc;
338}
339
340static long
341ecryptfs_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
342{
343	struct file *lower_file = ecryptfs_file_to_lower(file);
344	long rc = -ENOTTY;
345
346	if (!lower_file->f_op->unlocked_ioctl)
347		return rc;
348
349	switch (cmd) {
350	case FITRIM:
351	case FS_IOC_GETFLAGS:
352	case FS_IOC_SETFLAGS:
353	case FS_IOC_GETVERSION:
354	case FS_IOC_SETVERSION:
355		rc = lower_file->f_op->unlocked_ioctl(lower_file, cmd, arg);
356		fsstack_copy_attr_all(file_inode(file), file_inode(lower_file));
357
358		return rc;
359	default:
360		return rc;
361	}
362}
363
364#ifdef CONFIG_COMPAT
365static long
366ecryptfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
367{
368	struct file *lower_file = ecryptfs_file_to_lower(file);
369	long rc = -ENOIOCTLCMD;
370
371	if (!lower_file->f_op->compat_ioctl)
372		return rc;
373
374	switch (cmd) {
375	case FITRIM:
376	case FS_IOC32_GETFLAGS:
377	case FS_IOC32_SETFLAGS:
378	case FS_IOC32_GETVERSION:
379	case FS_IOC32_SETVERSION:
380		rc = lower_file->f_op->compat_ioctl(lower_file, cmd, arg);
381		fsstack_copy_attr_all(file_inode(file), file_inode(lower_file));
382
383		return rc;
384	default:
385		return rc;
386	}
387}
388#endif
389
390const struct file_operations ecryptfs_dir_fops = {
391	.iterate_shared = ecryptfs_readdir,
392	.read = generic_read_dir,
393	.unlocked_ioctl = ecryptfs_unlocked_ioctl,
394#ifdef CONFIG_COMPAT
395	.compat_ioctl = ecryptfs_compat_ioctl,
396#endif
397	.open = ecryptfs_dir_open,
398	.release = ecryptfs_dir_release,
399	.fsync = ecryptfs_fsync,
400	.llseek = ecryptfs_dir_llseek,
401};
402
403const struct file_operations ecryptfs_main_fops = {
404	.llseek = generic_file_llseek,
405	.read_iter = ecryptfs_read_update_atime,
406	.write_iter = generic_file_write_iter,
407	.unlocked_ioctl = ecryptfs_unlocked_ioctl,
408#ifdef CONFIG_COMPAT
409	.compat_ioctl = ecryptfs_compat_ioctl,
410#endif
411	.mmap = ecryptfs_mmap,
412	.open = ecryptfs_open,
413	.flush = ecryptfs_flush,
414	.release = ecryptfs_release,
415	.fsync = ecryptfs_fsync,
416	.fasync = ecryptfs_fasync,
417	.splice_read = generic_file_splice_read,
418};