11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2d17074acSLee Jones /*
3237fead6SMichael Halcrow * eCryptfs: Linux filesystem encryption layer
4237fead6SMichael Halcrow *
5237fead6SMichael Halcrow * Copyright (C) 1997-2004 Erez Zadok
6237fead6SMichael Halcrow * Copyright (C) 2001-2004 Stony Brook University
7dd2a3b7aSMichael Halcrow * Copyright (C) 2004-2007 International Business Machines Corp.
8237fead6SMichael Halcrow * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
9237fead6SMichael Halcrow * Michael C. Thompsion <mcthomps@us.ibm.com>
10237fead6SMichael Halcrow */
11237fead6SMichael Halcrow
12237fead6SMichael Halcrow #include <linux/file.h>
13237fead6SMichael Halcrow #include <linux/vmalloc.h>
14237fead6SMichael Halcrow #include <linux/pagemap.h>
15237fead6SMichael Halcrow #include <linux/dcache.h>
16237fead6SMichael Halcrow #include <linux/namei.h>
17237fead6SMichael Halcrow #include <linux/mount.h>
180cc72dc7SJosef "Jeff" Sipek #include <linux/fs_stack.h>
195a0e3ad6STejun Heo #include <linux/slab.h>
2048b512e6SRoberto Sassu #include <linux/xattr.h>
21af84016fSChristian Brauner #include <linux/posix_acl.h>
22af84016fSChristian Brauner #include <linux/posix_acl_xattr.h>
2397e2dee9SMiklos Szeredi #include <linux/fileattr.h>
240a688ad7SHarvey Harrison #include <asm/unaligned.h>
25237fead6SMichael Halcrow #include "ecryptfs_kernel.h"
26237fead6SMichael Halcrow
lock_parent(struct dentry * dentry,struct dentry ** lower_dentry,struct inode ** lower_dir)27b2648d51SAl Viro static int lock_parent(struct dentry *dentry,
28b2648d51SAl Viro struct dentry **lower_dentry,
29b2648d51SAl Viro struct inode **lower_dir)
30237fead6SMichael Halcrow {
31b2648d51SAl Viro struct dentry *lower_dir_dentry;
32237fead6SMichael Halcrow
33b2648d51SAl Viro lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);
34b2648d51SAl Viro *lower_dir = d_inode(lower_dir_dentry);
35b2648d51SAl Viro *lower_dentry = ecryptfs_dentry_to_lower(dentry);
36237fead6SMichael Halcrow
37b2648d51SAl Viro inode_lock_nested(*lower_dir, I_MUTEX_PARENT);
38b2648d51SAl Viro return (*lower_dentry)->d_parent == lower_dir_dentry ? 0 : -EINVAL;
39237fead6SMichael Halcrow }
40237fead6SMichael Halcrow
ecryptfs_inode_test(struct inode * inode,void * lower_inode)41c4f79073STyler Hicks static int ecryptfs_inode_test(struct inode *inode, void *lower_inode)
42c4f79073STyler Hicks {
43c4cf3ba4SHimangi Saraogi return ecryptfs_inode_to_lower(inode) == lower_inode;
44c4f79073STyler Hicks }
45c4f79073STyler Hicks
ecryptfs_inode_set(struct inode * inode,void * opaque)465ccf9203STyler Hicks static int ecryptfs_inode_set(struct inode *inode, void *opaque)
47c4f79073STyler Hicks {
485ccf9203STyler Hicks struct inode *lower_inode = opaque;
495ccf9203STyler Hicks
505ccf9203STyler Hicks ecryptfs_set_inode_lower(inode, lower_inode);
515ccf9203STyler Hicks fsstack_copy_attr_all(inode, lower_inode);
525ccf9203STyler Hicks /* i_size will be overwritten for encrypted regular files */
535ccf9203STyler Hicks fsstack_copy_inode_size(inode, lower_inode);
545ccf9203STyler Hicks inode->i_ino = lower_inode->i_ino;
55c4f79073STyler Hicks inode->i_mapping->a_ops = &ecryptfs_aops;
565ccf9203STyler Hicks
575ccf9203STyler Hicks if (S_ISLNK(inode->i_mode))
585ccf9203STyler Hicks inode->i_op = &ecryptfs_symlink_iops;
595ccf9203STyler Hicks else if (S_ISDIR(inode->i_mode))
605ccf9203STyler Hicks inode->i_op = &ecryptfs_dir_iops;
615ccf9203STyler Hicks else
625ccf9203STyler Hicks inode->i_op = &ecryptfs_main_iops;
635ccf9203STyler Hicks
645ccf9203STyler Hicks if (S_ISDIR(inode->i_mode))
655ccf9203STyler Hicks inode->i_fop = &ecryptfs_dir_fops;
665ccf9203STyler Hicks else if (special_file(inode->i_mode))
675ccf9203STyler Hicks init_special_inode(inode, inode->i_mode, inode->i_rdev);
685ccf9203STyler Hicks else
695ccf9203STyler Hicks inode->i_fop = &ecryptfs_main_fops;
705ccf9203STyler Hicks
71c4f79073STyler Hicks return 0;
72c4f79073STyler Hicks }
73c4f79073STyler Hicks
__ecryptfs_get_inode(struct inode * lower_inode,struct super_block * sb)745ccf9203STyler Hicks static struct inode *__ecryptfs_get_inode(struct inode *lower_inode,
755ccf9203STyler Hicks struct super_block *sb)
765ccf9203STyler Hicks {
775ccf9203STyler Hicks struct inode *inode;
785ccf9203STyler Hicks
795ccf9203STyler Hicks if (lower_inode->i_sb != ecryptfs_superblock_to_lower(sb))
805ccf9203STyler Hicks return ERR_PTR(-EXDEV);
81*d08534ebSGabriel Krisman Bertazi
82*d08534ebSGabriel Krisman Bertazi /* Reject dealing with casefold directories. */
83*d08534ebSGabriel Krisman Bertazi if (IS_CASEFOLDED(lower_inode)) {
84*d08534ebSGabriel Krisman Bertazi pr_err_ratelimited("%s: Can't handle casefolded directory.\n",
85*d08534ebSGabriel Krisman Bertazi __func__);
86*d08534ebSGabriel Krisman Bertazi return ERR_PTR(-EREMOTE);
87*d08534ebSGabriel Krisman Bertazi }
88*d08534ebSGabriel Krisman Bertazi
895ccf9203STyler Hicks if (!igrab(lower_inode))
905ccf9203STyler Hicks return ERR_PTR(-ESTALE);
915ccf9203STyler Hicks inode = iget5_locked(sb, (unsigned long)lower_inode,
925ccf9203STyler Hicks ecryptfs_inode_test, ecryptfs_inode_set,
935ccf9203STyler Hicks lower_inode);
945ccf9203STyler Hicks if (!inode) {
955ccf9203STyler Hicks iput(lower_inode);
965ccf9203STyler Hicks return ERR_PTR(-EACCES);
975ccf9203STyler Hicks }
985ccf9203STyler Hicks if (!(inode->i_state & I_NEW))
995ccf9203STyler Hicks iput(lower_inode);
1005ccf9203STyler Hicks
1015ccf9203STyler Hicks return inode;
1025ccf9203STyler Hicks }
1035ccf9203STyler Hicks
ecryptfs_get_inode(struct inode * lower_inode,struct super_block * sb)104c4f79073STyler Hicks struct inode *ecryptfs_get_inode(struct inode *lower_inode,
105c4f79073STyler Hicks struct super_block *sb)
106c4f79073STyler Hicks {
1075ccf9203STyler Hicks struct inode *inode = __ecryptfs_get_inode(lower_inode, sb);
108c4f79073STyler Hicks
1095ccf9203STyler Hicks if (!IS_ERR(inode) && (inode->i_state & I_NEW))
110c4f79073STyler Hicks unlock_new_inode(inode);
1115ccf9203STyler Hicks
112c4f79073STyler Hicks return inode;
113c4f79073STyler Hicks }
114c4f79073STyler Hicks
115c4f79073STyler Hicks /**
116c4f79073STyler Hicks * ecryptfs_interpose
117c4f79073STyler Hicks * @lower_dentry: Existing dentry in the lower filesystem
118c4f79073STyler Hicks * @dentry: ecryptfs' dentry
119c4f79073STyler Hicks * @sb: ecryptfs's super_block
120c4f79073STyler Hicks *
121c4f79073STyler Hicks * Interposes upper and lower dentries.
122c4f79073STyler Hicks *
123c4f79073STyler Hicks * Returns zero on success; non-zero otherwise
124c4f79073STyler Hicks */
ecryptfs_interpose(struct dentry * lower_dentry,struct dentry * dentry,struct super_block * sb)125c4f79073STyler Hicks static int ecryptfs_interpose(struct dentry *lower_dentry,
1265ccf9203STyler Hicks struct dentry *dentry, struct super_block *sb)
127c4f79073STyler Hicks {
1282b0143b5SDavid Howells struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb);
1295ccf9203STyler Hicks
130c4f79073STyler Hicks if (IS_ERR(inode))
131c4f79073STyler Hicks return PTR_ERR(inode);
132c4f79073STyler Hicks d_instantiate(dentry, inode);
1335ccf9203STyler Hicks
134c4f79073STyler Hicks return 0;
135c4f79073STyler Hicks }
136c4f79073STyler Hicks
ecryptfs_do_unlink(struct inode * dir,struct dentry * dentry,struct inode * inode)1378bc2d3cfSTyler Hicks static int ecryptfs_do_unlink(struct inode *dir, struct dentry *dentry,
1388bc2d3cfSTyler Hicks struct inode *inode)
1398bc2d3cfSTyler Hicks {
140b2648d51SAl Viro struct dentry *lower_dentry;
141b2648d51SAl Viro struct inode *lower_dir;
1428bc2d3cfSTyler Hicks int rc;
1438bc2d3cfSTyler Hicks
144b2648d51SAl Viro rc = lock_parent(dentry, &lower_dentry, &lower_dir);
145bcf0d9d4SAl Viro dget(lower_dentry); // don't even try to make the lower negative
146b2648d51SAl Viro if (!rc) {
147b2648d51SAl Viro if (d_unhashed(lower_dentry))
148bcf0d9d4SAl Viro rc = -EINVAL;
149bcf0d9d4SAl Viro else
150abf08576SChristian Brauner rc = vfs_unlink(&nop_mnt_idmap, lower_dir, lower_dentry,
1516521f891SChristian Brauner NULL);
152b2648d51SAl Viro }
1538bc2d3cfSTyler Hicks if (rc) {
1548bc2d3cfSTyler Hicks printk(KERN_ERR "Error in vfs_unlink; rc = [%d]\n", rc);
1558bc2d3cfSTyler Hicks goto out_unlock;
1568bc2d3cfSTyler Hicks }
157b2648d51SAl Viro fsstack_copy_attr_times(dir, lower_dir);
1588bc2d3cfSTyler Hicks set_nlink(inode, ecryptfs_inode_to_lower(inode)->i_nlink);
15979d9ce76SJeff Layton inode_set_ctime_to_ts(inode, inode_get_ctime(dir));
1608bc2d3cfSTyler Hicks out_unlock:
1618bc2d3cfSTyler Hicks dput(lower_dentry);
162b2648d51SAl Viro inode_unlock(lower_dir);
163bcf0d9d4SAl Viro if (!rc)
164bcf0d9d4SAl Viro d_drop(dentry);
1658bc2d3cfSTyler Hicks return rc;
1668bc2d3cfSTyler Hicks }
1678bc2d3cfSTyler Hicks
168237fead6SMichael Halcrow /**
169237fead6SMichael Halcrow * ecryptfs_do_create
170237fead6SMichael Halcrow * @directory_inode: inode of the new file's dentry's parent in ecryptfs
171237fead6SMichael Halcrow * @ecryptfs_dentry: New file's dentry in ecryptfs
172237fead6SMichael Halcrow * @mode: The mode of the new file
173237fead6SMichael Halcrow *
174237fead6SMichael Halcrow * Creates the underlying file and the eCryptfs inode which will link to
175237fead6SMichael Halcrow * it. It will also update the eCryptfs directory inode to mimic the
176237fead6SMichael Halcrow * stat of the lower directory inode.
177237fead6SMichael Halcrow *
178b59db43aSTyler Hicks * Returns the new eCryptfs inode on success; an ERR_PTR on error condition
179237fead6SMichael Halcrow */
180b59db43aSTyler Hicks static struct inode *
ecryptfs_do_create(struct inode * directory_inode,struct dentry * ecryptfs_dentry,umode_t mode)181237fead6SMichael Halcrow ecryptfs_do_create(struct inode *directory_inode,
182175a4eb7SAl Viro struct dentry *ecryptfs_dentry, umode_t mode)
183237fead6SMichael Halcrow {
184237fead6SMichael Halcrow int rc;
185237fead6SMichael Halcrow struct dentry *lower_dentry;
186b2648d51SAl Viro struct inode *lower_dir;
187b59db43aSTyler Hicks struct inode *inode;
188237fead6SMichael Halcrow
189b2648d51SAl Viro rc = lock_parent(ecryptfs_dentry, &lower_dentry, &lower_dir);
190b2648d51SAl Viro if (!rc)
191abf08576SChristian Brauner rc = vfs_create(&nop_mnt_idmap, lower_dir,
192b2648d51SAl Viro lower_dentry, mode, true);
1934981e081SMichael Halcrow if (rc) {
194caeeeecfSMichael Halcrow printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
19518d1dbf1SHarvey Harrison "rc = [%d]\n", __func__, rc);
196b59db43aSTyler Hicks inode = ERR_PTR(rc);
197237fead6SMichael Halcrow goto out_lock;
198237fead6SMichael Halcrow }
1992b0143b5SDavid Howells inode = __ecryptfs_get_inode(d_inode(lower_dentry),
2005ccf9203STyler Hicks directory_inode->i_sb);
2018bc2d3cfSTyler Hicks if (IS_ERR(inode)) {
202abf08576SChristian Brauner vfs_unlink(&nop_mnt_idmap, lower_dir, lower_dentry, NULL);
203237fead6SMichael Halcrow goto out_lock;
2048bc2d3cfSTyler Hicks }
205b2648d51SAl Viro fsstack_copy_attr_times(directory_inode, lower_dir);
206b2648d51SAl Viro fsstack_copy_inode_size(directory_inode, lower_dir);
207237fead6SMichael Halcrow out_lock:
208b2648d51SAl Viro inode_unlock(lower_dir);
209b59db43aSTyler Hicks return inode;
210237fead6SMichael Halcrow }
211237fead6SMichael Halcrow
212d17074acSLee Jones /*
213237fead6SMichael Halcrow * ecryptfs_initialize_file
214237fead6SMichael Halcrow *
215237fead6SMichael Halcrow * Cause the file to be changed from a basic empty file to an ecryptfs
216237fead6SMichael Halcrow * file with a header and first data page.
217237fead6SMichael Halcrow *
218237fead6SMichael Halcrow * Returns zero on success
219237fead6SMichael Halcrow */
ecryptfs_initialize_file(struct dentry * ecryptfs_dentry,struct inode * ecryptfs_inode)220e3ccaa97STyler Hicks int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry,
221b59db43aSTyler Hicks struct inode *ecryptfs_inode)
222237fead6SMichael Halcrow {
223d7cdc5feSMichael Halcrow struct ecryptfs_crypt_stat *crypt_stat =
224b59db43aSTyler Hicks &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
225237fead6SMichael Halcrow int rc = 0;
226237fead6SMichael Halcrow
227b59db43aSTyler Hicks if (S_ISDIR(ecryptfs_inode->i_mode)) {
228237fead6SMichael Halcrow ecryptfs_printk(KERN_DEBUG, "This is a directory\n");
229e2bd99ecSMichael Halcrow crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
230d7cdc5feSMichael Halcrow goto out;
231237fead6SMichael Halcrow }
232237fead6SMichael Halcrow ecryptfs_printk(KERN_DEBUG, "Initializing crypto context\n");
233b59db43aSTyler Hicks rc = ecryptfs_new_file_context(ecryptfs_inode);
234237fead6SMichael Halcrow if (rc) {
235d7cdc5feSMichael Halcrow ecryptfs_printk(KERN_ERR, "Error creating new file "
236d7cdc5feSMichael Halcrow "context; rc = [%d]\n", rc);
237d7cdc5feSMichael Halcrow goto out;
238237fead6SMichael Halcrow }
239b59db43aSTyler Hicks rc = ecryptfs_get_lower_file(ecryptfs_dentry, ecryptfs_inode);
240391b52f9SMichael Halcrow if (rc) {
241391b52f9SMichael Halcrow printk(KERN_ERR "%s: Error attempting to initialize "
242332ab16fSTyler Hicks "the lower file for the dentry with name "
2439e78d14aSDavid Howells "[%pd]; rc = [%d]\n", __func__,
2449e78d14aSDavid Howells ecryptfs_dentry, rc);
245391b52f9SMichael Halcrow goto out;
246391b52f9SMichael Halcrow }
247b59db43aSTyler Hicks rc = ecryptfs_write_metadata(ecryptfs_dentry, ecryptfs_inode);
248332ab16fSTyler Hicks if (rc)
249d7cdc5feSMichael Halcrow printk(KERN_ERR "Error writing headers; rc = [%d]\n", rc);
250b59db43aSTyler Hicks ecryptfs_put_lower_file(ecryptfs_inode);
251237fead6SMichael Halcrow out:
252237fead6SMichael Halcrow return rc;
253237fead6SMichael Halcrow }
254237fead6SMichael Halcrow
255d17074acSLee Jones /*
256237fead6SMichael Halcrow * ecryptfs_create
257237fead6SMichael Halcrow * @mode: The mode of the new file.
258237fead6SMichael Halcrow *
259237fead6SMichael Halcrow * Creates a new file.
260237fead6SMichael Halcrow *
261237fead6SMichael Halcrow * Returns zero on success; non-zero on error condition
262237fead6SMichael Halcrow */
263237fead6SMichael Halcrow static int
ecryptfs_create(struct mnt_idmap * idmap,struct inode * directory_inode,struct dentry * ecryptfs_dentry,umode_t mode,bool excl)2646c960e68SChristian Brauner ecryptfs_create(struct mnt_idmap *idmap,
265549c7297SChristian Brauner struct inode *directory_inode, struct dentry *ecryptfs_dentry,
266ebfc3b49SAl Viro umode_t mode, bool excl)
267237fead6SMichael Halcrow {
268b59db43aSTyler Hicks struct inode *ecryptfs_inode;
269237fead6SMichael Halcrow int rc;
270237fead6SMichael Halcrow
271b59db43aSTyler Hicks ecryptfs_inode = ecryptfs_do_create(directory_inode, ecryptfs_dentry,
272b59db43aSTyler Hicks mode);
273a1c83681SViresh Kumar if (IS_ERR(ecryptfs_inode)) {
274237fead6SMichael Halcrow ecryptfs_printk(KERN_WARNING, "Failed to create file in"
275237fead6SMichael Halcrow "lower filesystem\n");
276b59db43aSTyler Hicks rc = PTR_ERR(ecryptfs_inode);
277237fead6SMichael Halcrow goto out;
278237fead6SMichael Halcrow }
279237fead6SMichael Halcrow /* At this point, a file exists on "disk"; we need to make sure
280237fead6SMichael Halcrow * that this on disk file is prepared to be an ecryptfs file */
281b59db43aSTyler Hicks rc = ecryptfs_initialize_file(ecryptfs_dentry, ecryptfs_inode);
282b59db43aSTyler Hicks if (rc) {
2838bc2d3cfSTyler Hicks ecryptfs_do_unlink(directory_inode, ecryptfs_dentry,
2848bc2d3cfSTyler Hicks ecryptfs_inode);
2850e81ba23SAl Viro iget_failed(ecryptfs_inode);
286b59db43aSTyler Hicks goto out;
287b59db43aSTyler Hicks }
2881e2e547aSAl Viro d_instantiate_new(ecryptfs_dentry, ecryptfs_inode);
289237fead6SMichael Halcrow out:
290237fead6SMichael Halcrow return rc;
291237fead6SMichael Halcrow }
292237fead6SMichael Halcrow
ecryptfs_i_size_read(struct dentry * dentry,struct inode * inode)293778aeb42STyler Hicks static int ecryptfs_i_size_read(struct dentry *dentry, struct inode *inode)
294237fead6SMichael Halcrow {
2952aac0cf8STyler Hicks struct ecryptfs_crypt_stat *crypt_stat;
296778aeb42STyler Hicks int rc;
297237fead6SMichael Halcrow
298778aeb42STyler Hicks rc = ecryptfs_get_lower_file(dentry, inode);
299391b52f9SMichael Halcrow if (rc) {
300391b52f9SMichael Halcrow printk(KERN_ERR "%s: Error attempting to initialize "
301332ab16fSTyler Hicks "the lower file for the dentry with name "
3029e78d14aSDavid Howells "[%pd]; rc = [%d]\n", __func__,
3039e78d14aSDavid Howells dentry, rc);
304778aeb42STyler Hicks return rc;
305391b52f9SMichael Halcrow }
306778aeb42STyler Hicks
3073b06b3ebSTyler Hicks crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
3082aac0cf8STyler Hicks /* TODO: lock for crypt_stat comparison */
3092aac0cf8STyler Hicks if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED))
3102aac0cf8STyler Hicks ecryptfs_set_default_sizes(crypt_stat);
311778aeb42STyler Hicks
312778aeb42STyler Hicks rc = ecryptfs_read_and_validate_header_region(inode);
313778aeb42STyler Hicks ecryptfs_put_lower_file(inode);
314237fead6SMichael Halcrow if (rc) {
315778aeb42STyler Hicks rc = ecryptfs_read_and_validate_xattr_region(dentry, inode);
316778aeb42STyler Hicks if (!rc)
317dd2a3b7aSMichael Halcrow crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;
318dd2a3b7aSMichael Halcrow }
319778aeb42STyler Hicks
320778aeb42STyler Hicks /* Must return 0 to allow non-eCryptfs files to be looked up, too */
321778aeb42STyler Hicks return 0;
322778aeb42STyler Hicks }
323778aeb42STyler Hicks
324d17074acSLee Jones /*
325778aeb42STyler Hicks * ecryptfs_lookup_interpose - Dentry interposition for a lookup
326778aeb42STyler Hicks */
ecryptfs_lookup_interpose(struct dentry * dentry,struct dentry * lower_dentry)327b1168a92SAl Viro static struct dentry *ecryptfs_lookup_interpose(struct dentry *dentry,
328b1168a92SAl Viro struct dentry *lower_dentry)
329778aeb42STyler Hicks {
33088569546SAl Viro const struct path *path = ecryptfs_dentry_to_lower_path(dentry->d_parent);
331e72b9dd6SAl Viro struct inode *inode, *lower_inode;
332778aeb42STyler Hicks struct ecryptfs_dentry_info *dentry_info;
333778aeb42STyler Hicks int rc = 0;
334778aeb42STyler Hicks
335778aeb42STyler Hicks dentry_info = kmem_cache_alloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
336778aeb42STyler Hicks if (!dentry_info) {
337237fead6SMichael Halcrow dput(lower_dentry);
338b1168a92SAl Viro return ERR_PTR(-ENOMEM);
339778aeb42STyler Hicks }
3400b1d9011SAl Viro
341b1168a92SAl Viro fsstack_copy_attr_atime(d_inode(dentry->d_parent),
342762c6968SAl Viro d_inode(path->dentry));
34384d08fa8SAl Viro BUG_ON(!d_count(lower_dentry));
3440b1d9011SAl Viro
3450b1d9011SAl Viro ecryptfs_set_dentry_private(dentry, dentry_info);
346762c6968SAl Viro dentry_info->lower_path.mnt = mntget(path->mnt);
34792dd1230SAl Viro dentry_info->lower_path.dentry = lower_dentry;
348778aeb42STyler Hicks
349e72b9dd6SAl Viro /*
350e72b9dd6SAl Viro * negative dentry can go positive under us here - its parent is not
351e72b9dd6SAl Viro * locked. That's OK and that could happen just as we return from
352e72b9dd6SAl Viro * ecryptfs_lookup() anyway. Just need to be careful and fetch
353e72b9dd6SAl Viro * ->d_inode only once - it's not stable here.
354e72b9dd6SAl Viro */
355e72b9dd6SAl Viro lower_inode = READ_ONCE(lower_dentry->d_inode);
356e72b9dd6SAl Viro
357e72b9dd6SAl Viro if (!lower_inode) {
358778aeb42STyler Hicks /* We want to add because we couldn't find in lower */
359778aeb42STyler Hicks d_add(dentry, NULL);
360b1168a92SAl Viro return NULL;
361778aeb42STyler Hicks }
362b1168a92SAl Viro inode = __ecryptfs_get_inode(lower_inode, dentry->d_sb);
363778aeb42STyler Hicks if (IS_ERR(inode)) {
364778aeb42STyler Hicks printk(KERN_ERR "%s: Error interposing; rc = [%ld]\n",
365778aeb42STyler Hicks __func__, PTR_ERR(inode));
366b1168a92SAl Viro return ERR_CAST(inode);
367778aeb42STyler Hicks }
368778aeb42STyler Hicks if (S_ISREG(inode->i_mode)) {
369778aeb42STyler Hicks rc = ecryptfs_i_size_read(dentry, inode);
370778aeb42STyler Hicks if (rc) {
371778aeb42STyler Hicks make_bad_inode(inode);
372b1168a92SAl Viro return ERR_PTR(rc);
373778aeb42STyler Hicks }
374778aeb42STyler Hicks }
375778aeb42STyler Hicks
376778aeb42STyler Hicks if (inode->i_state & I_NEW)
377778aeb42STyler Hicks unlock_new_inode(inode);
378b1168a92SAl Viro return d_splice_alias(inode, dentry);
379addd65adSMichael Halcrow }
380addd65adSMichael Halcrow
381addd65adSMichael Halcrow /**
382addd65adSMichael Halcrow * ecryptfs_lookup
383addd65adSMichael Halcrow * @ecryptfs_dir_inode: The eCryptfs directory inode
384addd65adSMichael Halcrow * @ecryptfs_dentry: The eCryptfs dentry that we are looking up
38589076bc3SAl Viro * @flags: lookup flags
386addd65adSMichael Halcrow *
387addd65adSMichael Halcrow * Find a file on disk. If the file does not exist, then we'll add it to the
388addd65adSMichael Halcrow * dentry cache and continue on to read it from the disk.
389addd65adSMichael Halcrow */
ecryptfs_lookup(struct inode * ecryptfs_dir_inode,struct dentry * ecryptfs_dentry,unsigned int flags)390addd65adSMichael Halcrow static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
391addd65adSMichael Halcrow struct dentry *ecryptfs_dentry,
39200cd8dd3SAl Viro unsigned int flags)
393addd65adSMichael Halcrow {
394addd65adSMichael Halcrow char *encrypted_and_encoded_name = NULL;
39588ae4ab9SAl Viro struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
396addd65adSMichael Halcrow struct dentry *lower_dir_dentry, *lower_dentry;
39788ae4ab9SAl Viro const char *name = ecryptfs_dentry->d_name.name;
39888ae4ab9SAl Viro size_t len = ecryptfs_dentry->d_name.len;
399b1168a92SAl Viro struct dentry *res;
400addd65adSMichael Halcrow int rc = 0;
401addd65adSMichael Halcrow
402addd65adSMichael Halcrow lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
40388ae4ab9SAl Viro
404addd65adSMichael Halcrow mount_crypt_stat = &ecryptfs_superblock_to_private(
405addd65adSMichael Halcrow ecryptfs_dentry->d_sb)->mount_crypt_stat;
406ab13a921SGuenter Roeck if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
407addd65adSMichael Halcrow rc = ecryptfs_encrypt_and_encode_filename(
40888ae4ab9SAl Viro &encrypted_and_encoded_name, &len,
40988ae4ab9SAl Viro mount_crypt_stat, name, len);
410addd65adSMichael Halcrow if (rc) {
411addd65adSMichael Halcrow printk(KERN_ERR "%s: Error attempting to encrypt and encode "
412addd65adSMichael Halcrow "filename; rc = [%d]\n", __func__, rc);
413237fead6SMichael Halcrow return ERR_PTR(rc);
414237fead6SMichael Halcrow }
41588ae4ab9SAl Viro name = encrypted_and_encoded_name;
41688ae4ab9SAl Viro }
41788ae4ab9SAl Viro
41888ae4ab9SAl Viro lower_dentry = lookup_one_len_unlocked(name, lower_dir_dentry, len);
419237fead6SMichael Halcrow if (IS_ERR(lower_dentry)) {
420237fead6SMichael Halcrow ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
421b1168a92SAl Viro "[%ld] on lower_dentry = [%s]\n", __func__,
422b1168a92SAl Viro PTR_ERR(lower_dentry),
42388ae4ab9SAl Viro name);
424b1168a92SAl Viro res = ERR_CAST(lower_dentry);
42588ae4ab9SAl Viro } else {
426b1168a92SAl Viro res = ecryptfs_lookup_interpose(ecryptfs_dentry, lower_dentry);
42788ae4ab9SAl Viro }
428237fead6SMichael Halcrow kfree(encrypted_and_encoded_name);
429b1168a92SAl Viro return res;
430237fead6SMichael Halcrow }
431237fead6SMichael Halcrow
ecryptfs_link(struct dentry * old_dentry,struct inode * dir,struct dentry * new_dentry)432237fead6SMichael Halcrow static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,
433237fead6SMichael Halcrow struct dentry *new_dentry)
434237fead6SMichael Halcrow {
435237fead6SMichael Halcrow struct dentry *lower_old_dentry;
436237fead6SMichael Halcrow struct dentry *lower_new_dentry;
437b2648d51SAl Viro struct inode *lower_dir;
438237fead6SMichael Halcrow u64 file_size_save;
439237fead6SMichael Halcrow int rc;
440237fead6SMichael Halcrow
4412b0143b5SDavid Howells file_size_save = i_size_read(d_inode(old_dentry));
442237fead6SMichael Halcrow lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
443b2648d51SAl Viro rc = lock_parent(new_dentry, &lower_new_dentry, &lower_dir);
444b2648d51SAl Viro if (!rc)
445abf08576SChristian Brauner rc = vfs_link(lower_old_dentry, &nop_mnt_idmap, lower_dir,
446b2648d51SAl Viro lower_new_dentry, NULL);
4472b0143b5SDavid Howells if (rc || d_really_is_negative(lower_new_dentry))
448237fead6SMichael Halcrow goto out_lock;
4495ccf9203STyler Hicks rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);
450237fead6SMichael Halcrow if (rc)
451237fead6SMichael Halcrow goto out_lock;
452b2648d51SAl Viro fsstack_copy_attr_times(dir, lower_dir);
453b2648d51SAl Viro fsstack_copy_inode_size(dir, lower_dir);
4542b0143b5SDavid Howells set_nlink(d_inode(old_dentry),
4552b0143b5SDavid Howells ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink);
4562b0143b5SDavid Howells i_size_write(d_inode(new_dentry), file_size_save);
457237fead6SMichael Halcrow out_lock:
458b2648d51SAl Viro inode_unlock(lower_dir);
459237fead6SMichael Halcrow return rc;
460237fead6SMichael Halcrow }
461237fead6SMichael Halcrow
ecryptfs_unlink(struct inode * dir,struct dentry * dentry)462237fead6SMichael Halcrow static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
463237fead6SMichael Halcrow {
4642b0143b5SDavid Howells return ecryptfs_do_unlink(dir, dentry, d_inode(dentry));
465237fead6SMichael Halcrow }
466237fead6SMichael Halcrow
ecryptfs_symlink(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,const char * symname)4677a77db95SChristian Brauner static int ecryptfs_symlink(struct mnt_idmap *idmap,
468549c7297SChristian Brauner struct inode *dir, struct dentry *dentry,
469237fead6SMichael Halcrow const char *symname)
470237fead6SMichael Halcrow {
471237fead6SMichael Halcrow int rc;
472237fead6SMichael Halcrow struct dentry *lower_dentry;
473b2648d51SAl Viro struct inode *lower_dir;
474237fead6SMichael Halcrow char *encoded_symname;
475addd65adSMichael Halcrow size_t encoded_symlen;
476addd65adSMichael Halcrow struct ecryptfs_mount_crypt_stat *mount_crypt_stat = NULL;
477237fead6SMichael Halcrow
478b2648d51SAl Viro rc = lock_parent(dentry, &lower_dentry, &lower_dir);
479b2648d51SAl Viro if (rc)
480b2648d51SAl Viro goto out_lock;
481addd65adSMichael Halcrow mount_crypt_stat = &ecryptfs_superblock_to_private(
482addd65adSMichael Halcrow dir->i_sb)->mount_crypt_stat;
483addd65adSMichael Halcrow rc = ecryptfs_encrypt_and_encode_filename(&encoded_symname,
484addd65adSMichael Halcrow &encoded_symlen,
485addd65adSMichael Halcrow mount_crypt_stat, symname,
486addd65adSMichael Halcrow strlen(symname));
487addd65adSMichael Halcrow if (rc)
488237fead6SMichael Halcrow goto out_lock;
489abf08576SChristian Brauner rc = vfs_symlink(&nop_mnt_idmap, lower_dir, lower_dentry,
490db2e747bSMiklos Szeredi encoded_symname);
491237fead6SMichael Halcrow kfree(encoded_symname);
4922b0143b5SDavid Howells if (rc || d_really_is_negative(lower_dentry))
493237fead6SMichael Halcrow goto out_lock;
4945ccf9203STyler Hicks rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
495237fead6SMichael Halcrow if (rc)
496237fead6SMichael Halcrow goto out_lock;
497b2648d51SAl Viro fsstack_copy_attr_times(dir, lower_dir);
498b2648d51SAl Viro fsstack_copy_inode_size(dir, lower_dir);
499237fead6SMichael Halcrow out_lock:
500b2648d51SAl Viro inode_unlock(lower_dir);
5012b0143b5SDavid Howells if (d_really_is_negative(dentry))
502237fead6SMichael Halcrow d_drop(dentry);
503237fead6SMichael Halcrow return rc;
504237fead6SMichael Halcrow }
505237fead6SMichael Halcrow
ecryptfs_mkdir(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode)506c54bd91eSChristian Brauner static int ecryptfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
507549c7297SChristian Brauner struct dentry *dentry, umode_t mode)
508237fead6SMichael Halcrow {
509237fead6SMichael Halcrow int rc;
510237fead6SMichael Halcrow struct dentry *lower_dentry;
511b2648d51SAl Viro struct inode *lower_dir;
512237fead6SMichael Halcrow
513b2648d51SAl Viro rc = lock_parent(dentry, &lower_dentry, &lower_dir);
514b2648d51SAl Viro if (!rc)
515abf08576SChristian Brauner rc = vfs_mkdir(&nop_mnt_idmap, lower_dir,
516b2648d51SAl Viro lower_dentry, mode);
5172b0143b5SDavid Howells if (rc || d_really_is_negative(lower_dentry))
518237fead6SMichael Halcrow goto out;
5195ccf9203STyler Hicks rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
520237fead6SMichael Halcrow if (rc)
521237fead6SMichael Halcrow goto out;
522b2648d51SAl Viro fsstack_copy_attr_times(dir, lower_dir);
523b2648d51SAl Viro fsstack_copy_inode_size(dir, lower_dir);
524b2648d51SAl Viro set_nlink(dir, lower_dir->i_nlink);
525237fead6SMichael Halcrow out:
526b2648d51SAl Viro inode_unlock(lower_dir);
5272b0143b5SDavid Howells if (d_really_is_negative(dentry))
528237fead6SMichael Halcrow d_drop(dentry);
529237fead6SMichael Halcrow return rc;
530237fead6SMichael Halcrow }
531237fead6SMichael Halcrow
ecryptfs_rmdir(struct inode * dir,struct dentry * dentry)532237fead6SMichael Halcrow static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
533237fead6SMichael Halcrow {
534237fead6SMichael Halcrow struct dentry *lower_dentry;
535b2648d51SAl Viro struct inode *lower_dir;
53645ec4abaSMichael Halcrow int rc;
537237fead6SMichael Halcrow
538b2648d51SAl Viro rc = lock_parent(dentry, &lower_dentry, &lower_dir);
539bcf0d9d4SAl Viro dget(lower_dentry); // don't even try to make the lower negative
540b2648d51SAl Viro if (!rc) {
541b2648d51SAl Viro if (d_unhashed(lower_dentry))
542bcf0d9d4SAl Viro rc = -EINVAL;
543bcf0d9d4SAl Viro else
544abf08576SChristian Brauner rc = vfs_rmdir(&nop_mnt_idmap, lower_dir, lower_dentry);
545b2648d51SAl Viro }
546bcf0d9d4SAl Viro if (!rc) {
5472b0143b5SDavid Howells clear_nlink(d_inode(dentry));
548b2648d51SAl Viro fsstack_copy_attr_times(dir, lower_dir);
549b2648d51SAl Viro set_nlink(dir, lower_dir->i_nlink);
550bcf0d9d4SAl Viro }
551bcf0d9d4SAl Viro dput(lower_dentry);
552b2648d51SAl Viro inode_unlock(lower_dir);
553237fead6SMichael Halcrow if (!rc)
554237fead6SMichael Halcrow d_drop(dentry);
555237fead6SMichael Halcrow return rc;
556237fead6SMichael Halcrow }
557237fead6SMichael Halcrow
558237fead6SMichael Halcrow static int
ecryptfs_mknod(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,dev_t dev)5595ebb29beSChristian Brauner ecryptfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
560549c7297SChristian Brauner struct dentry *dentry, umode_t mode, dev_t dev)
561237fead6SMichael Halcrow {
562237fead6SMichael Halcrow int rc;
563237fead6SMichael Halcrow struct dentry *lower_dentry;
564b2648d51SAl Viro struct inode *lower_dir;
565237fead6SMichael Halcrow
566b2648d51SAl Viro rc = lock_parent(dentry, &lower_dentry, &lower_dir);
567b2648d51SAl Viro if (!rc)
568abf08576SChristian Brauner rc = vfs_mknod(&nop_mnt_idmap, lower_dir,
569b2648d51SAl Viro lower_dentry, mode, dev);
5702b0143b5SDavid Howells if (rc || d_really_is_negative(lower_dentry))
571237fead6SMichael Halcrow goto out;
5725ccf9203STyler Hicks rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
573237fead6SMichael Halcrow if (rc)
574237fead6SMichael Halcrow goto out;
575b2648d51SAl Viro fsstack_copy_attr_times(dir, lower_dir);
576b2648d51SAl Viro fsstack_copy_inode_size(dir, lower_dir);
577237fead6SMichael Halcrow out:
578b2648d51SAl Viro inode_unlock(lower_dir);
5792b0143b5SDavid Howells if (d_really_is_negative(dentry))
580237fead6SMichael Halcrow d_drop(dentry);
581237fead6SMichael Halcrow return rc;
582237fead6SMichael Halcrow }
583237fead6SMichael Halcrow
584237fead6SMichael Halcrow static int
ecryptfs_rename(struct mnt_idmap * idmap,struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)585e18275aeSChristian Brauner ecryptfs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
586549c7297SChristian Brauner struct dentry *old_dentry, struct inode *new_dir,
587549c7297SChristian Brauner struct dentry *new_dentry, unsigned int flags)
588237fead6SMichael Halcrow {
589237fead6SMichael Halcrow int rc;
590237fead6SMichael Halcrow struct dentry *lower_old_dentry;
591237fead6SMichael Halcrow struct dentry *lower_new_dentry;
592237fead6SMichael Halcrow struct dentry *lower_old_dir_dentry;
593237fead6SMichael Halcrow struct dentry *lower_new_dir_dentry;
594bcf0d9d4SAl Viro struct dentry *trap;
5958335eafcSTyler Hicks struct inode *target_inode;
5969fe61450SChristian Brauner struct renamedata rd = {};
597237fead6SMichael Halcrow
5981cd66c93SMiklos Szeredi if (flags)
5991cd66c93SMiklos Szeredi return -EINVAL;
6001cd66c93SMiklos Szeredi
601bcf0d9d4SAl Viro lower_old_dir_dentry = ecryptfs_dentry_to_lower(old_dentry->d_parent);
602bcf0d9d4SAl Viro lower_new_dir_dentry = ecryptfs_dentry_to_lower(new_dentry->d_parent);
603bcf0d9d4SAl Viro
604237fead6SMichael Halcrow lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
605237fead6SMichael Halcrow lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
606bcf0d9d4SAl Viro
6072b0143b5SDavid Howells target_inode = d_inode(new_dentry);
608bcf0d9d4SAl Viro
6090d132f73SErez Zadok trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
610bcf0d9d4SAl Viro dget(lower_new_dentry);
6110d132f73SErez Zadok rc = -EINVAL;
61274dd7c97SAl Viro if (lower_old_dentry->d_parent != lower_old_dir_dentry)
6130d132f73SErez Zadok goto out_lock;
61474dd7c97SAl Viro if (lower_new_dentry->d_parent != lower_new_dir_dentry)
61574dd7c97SAl Viro goto out_lock;
61674dd7c97SAl Viro if (d_unhashed(lower_old_dentry) || d_unhashed(lower_new_dentry))
61774dd7c97SAl Viro goto out_lock;
61874dd7c97SAl Viro /* source should not be ancestor of target */
61974dd7c97SAl Viro if (trap == lower_old_dentry)
62074dd7c97SAl Viro goto out_lock;
6210d132f73SErez Zadok /* target should not be ancestor of source */
6220d132f73SErez Zadok if (trap == lower_new_dentry) {
6230d132f73SErez Zadok rc = -ENOTEMPTY;
6240d132f73SErez Zadok goto out_lock;
6250d132f73SErez Zadok }
6269fe61450SChristian Brauner
627abf08576SChristian Brauner rd.old_mnt_idmap = &nop_mnt_idmap;
6289fe61450SChristian Brauner rd.old_dir = d_inode(lower_old_dir_dentry);
6299fe61450SChristian Brauner rd.old_dentry = lower_old_dentry;
630abf08576SChristian Brauner rd.new_mnt_idmap = &nop_mnt_idmap;
6319fe61450SChristian Brauner rd.new_dir = d_inode(lower_new_dir_dentry);
6329fe61450SChristian Brauner rd.new_dentry = lower_new_dentry;
6339fe61450SChristian Brauner rc = vfs_rename(&rd);
634237fead6SMichael Halcrow if (rc)
635237fead6SMichael Halcrow goto out_lock;
6368335eafcSTyler Hicks if (target_inode)
6378335eafcSTyler Hicks fsstack_copy_attr_all(target_inode,
6388335eafcSTyler Hicks ecryptfs_inode_to_lower(target_inode));
6392b0143b5SDavid Howells fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));
640237fead6SMichael Halcrow if (new_dir != old_dir)
6412b0143b5SDavid Howells fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));
642237fead6SMichael Halcrow out_lock:
643237fead6SMichael Halcrow dput(lower_new_dentry);
644bcf0d9d4SAl Viro unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
645237fead6SMichael Halcrow return rc;
646237fead6SMichael Halcrow }
647237fead6SMichael Halcrow
ecryptfs_readlink_lower(struct dentry * dentry,size_t * bufsiz)648b22e8fedSAl Viro static char *ecryptfs_readlink_lower(struct dentry *dentry, size_t *bufsiz)
649237fead6SMichael Halcrow {
6506c988f57SMiklos Szeredi DEFINE_DELAYED_CALL(done);
6513a60a168STyler Hicks struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
6526c988f57SMiklos Szeredi const char *link;
653b22e8fedSAl Viro char *buf;
654addd65adSMichael Halcrow int rc;
655237fead6SMichael Halcrow
6566c988f57SMiklos Szeredi link = vfs_get_link(lower_dentry, &done);
6576c988f57SMiklos Szeredi if (IS_ERR(link))
6586c988f57SMiklos Szeredi return ERR_CAST(link);
6596c988f57SMiklos Szeredi
660b22e8fedSAl Viro rc = ecryptfs_decode_and_decrypt_filename(&buf, bufsiz, dentry->d_sb,
6616c988f57SMiklos Szeredi link, strlen(link));
6626c988f57SMiklos Szeredi do_delayed_call(&done);
6636c988f57SMiklos Szeredi if (rc)
6646c988f57SMiklos Szeredi return ERR_PTR(rc);
6656c988f57SMiklos Szeredi
6666c988f57SMiklos Szeredi return buf;
6673a60a168STyler Hicks }
6683a60a168STyler Hicks
ecryptfs_get_link(struct dentry * dentry,struct inode * inode,struct delayed_call * done)6696b255391SAl Viro static const char *ecryptfs_get_link(struct dentry *dentry,
670fceef393SAl Viro struct inode *inode,
671fceef393SAl Viro struct delayed_call *done)
672237fead6SMichael Halcrow {
673b22e8fedSAl Viro size_t len;
6746b255391SAl Viro char *buf;
6756b255391SAl Viro
6766b255391SAl Viro if (!dentry)
6776b255391SAl Viro return ERR_PTR(-ECHILD);
6786b255391SAl Viro
6796b255391SAl Viro buf = ecryptfs_readlink_lower(dentry, &len);
680b22e8fedSAl Viro if (IS_ERR(buf))
681680baacbSAl Viro return buf;
6822b0143b5SDavid Howells fsstack_copy_attr_atime(d_inode(dentry),
6832b0143b5SDavid Howells d_inode(ecryptfs_dentry_to_lower(dentry)));
684408bd629SAl Viro buf[len] = '\0';
685fceef393SAl Viro set_delayed_call(done, kfree_link, buf);
686fceef393SAl Viro return buf;
687237fead6SMichael Halcrow }
688237fead6SMichael Halcrow
689237fead6SMichael Halcrow /**
690237fead6SMichael Halcrow * upper_size_to_lower_size
691237fead6SMichael Halcrow * @crypt_stat: Crypt_stat associated with file
692237fead6SMichael Halcrow * @upper_size: Size of the upper file
693237fead6SMichael Halcrow *
694cc11beffSMichael Halcrow * Calculate the required size of the lower file based on the
695237fead6SMichael Halcrow * specified size of the upper file. This calculation is based on the
696237fead6SMichael Halcrow * number of headers in the underlying file and the extent size.
697237fead6SMichael Halcrow *
698237fead6SMichael Halcrow * Returns Calculated size of the lower file.
699237fead6SMichael Halcrow */
700237fead6SMichael Halcrow static loff_t
upper_size_to_lower_size(struct ecryptfs_crypt_stat * crypt_stat,loff_t upper_size)701237fead6SMichael Halcrow upper_size_to_lower_size(struct ecryptfs_crypt_stat *crypt_stat,
702237fead6SMichael Halcrow loff_t upper_size)
703237fead6SMichael Halcrow {
704237fead6SMichael Halcrow loff_t lower_size;
705237fead6SMichael Halcrow
706157f1071STyler Hicks lower_size = ecryptfs_lower_header_size(crypt_stat);
707237fead6SMichael Halcrow if (upper_size != 0) {
708237fead6SMichael Halcrow loff_t num_extents;
709237fead6SMichael Halcrow
710237fead6SMichael Halcrow num_extents = upper_size >> crypt_stat->extent_shift;
711237fead6SMichael Halcrow if (upper_size & ~crypt_stat->extent_mask)
712237fead6SMichael Halcrow num_extents++;
713237fead6SMichael Halcrow lower_size += (num_extents * crypt_stat->extent_size);
714237fead6SMichael Halcrow }
715237fead6SMichael Halcrow return lower_size;
716237fead6SMichael Halcrow }
717237fead6SMichael Halcrow
718237fead6SMichael Halcrow /**
7195f3ef64fSTyler Hicks * truncate_upper
720237fead6SMichael Halcrow * @dentry: The ecryptfs layer dentry
7215f3ef64fSTyler Hicks * @ia: Address of the ecryptfs inode's attributes
7225f3ef64fSTyler Hicks * @lower_ia: Address of the lower inode's attributes
723237fead6SMichael Halcrow *
724237fead6SMichael Halcrow * Function to handle truncations modifying the size of the file. Note
725237fead6SMichael Halcrow * that the file sizes are interpolated. When expanding, we are simply
7265f3ef64fSTyler Hicks * writing strings of 0's out. When truncating, we truncate the upper
7275f3ef64fSTyler Hicks * inode and update the lower_ia according to the page index
7285f3ef64fSTyler Hicks * interpolations. If ATTR_SIZE is set in lower_ia->ia_valid upon return,
7295f3ef64fSTyler Hicks * the caller must use lower_ia in a call to notify_change() to perform
7305f3ef64fSTyler Hicks * the truncation of the lower inode.
731237fead6SMichael Halcrow *
732237fead6SMichael Halcrow * Returns zero on success; non-zero otherwise
733237fead6SMichael Halcrow */
truncate_upper(struct dentry * dentry,struct iattr * ia,struct iattr * lower_ia)7345f3ef64fSTyler Hicks static int truncate_upper(struct dentry *dentry, struct iattr *ia,
7355f3ef64fSTyler Hicks struct iattr *lower_ia)
736237fead6SMichael Halcrow {
737237fead6SMichael Halcrow int rc = 0;
7382b0143b5SDavid Howells struct inode *inode = d_inode(dentry);
739237fead6SMichael Halcrow struct ecryptfs_crypt_stat *crypt_stat;
740237fead6SMichael Halcrow loff_t i_size = i_size_read(inode);
741237fead6SMichael Halcrow loff_t lower_size_before_truncate;
742237fead6SMichael Halcrow loff_t lower_size_after_truncate;
743237fead6SMichael Halcrow
7445f3ef64fSTyler Hicks if (unlikely((ia->ia_size == i_size))) {
7455f3ef64fSTyler Hicks lower_ia->ia_valid &= ~ATTR_SIZE;
746332ab16fSTyler Hicks return 0;
7475f3ef64fSTyler Hicks }
7483b06b3ebSTyler Hicks rc = ecryptfs_get_lower_file(dentry, inode);
749332ab16fSTyler Hicks if (rc)
750332ab16fSTyler Hicks return rc;
7512b0143b5SDavid Howells crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
752237fead6SMichael Halcrow /* Switch on growing or shrinking file */
7535f3ef64fSTyler Hicks if (ia->ia_size > i_size) {
7542ed92554SMichael Halcrow char zero[] = { 0x00 };
755240e2df5SMichael Halcrow
7565f3ef64fSTyler Hicks lower_ia->ia_valid &= ~ATTR_SIZE;
7572ed92554SMichael Halcrow /* Write a single 0 at the last position of the file;
7582ed92554SMichael Halcrow * this triggers code that will fill in 0's throughout
7592ed92554SMichael Halcrow * the intermediate portion of the previous end of the
7602ed92554SMichael Halcrow * file and the new and of the file */
76148c1e44aSAl Viro rc = ecryptfs_write(inode, zero,
7625f3ef64fSTyler Hicks (ia->ia_size - 1), 1);
7635f3ef64fSTyler Hicks } else { /* ia->ia_size < i_size_read(inode) */
7645f3ef64fSTyler Hicks /* We're chopping off all the pages down to the page
7655f3ef64fSTyler Hicks * in which ia->ia_size is located. Fill in the end of
766ea1754a0SKirill A. Shutemov * that page from (ia->ia_size & ~PAGE_MASK) to
767ea1754a0SKirill A. Shutemov * PAGE_SIZE with zeros. */
76809cbfeafSKirill A. Shutemov size_t num_zeros = (PAGE_SIZE
76909cbfeafSKirill A. Shutemov - (ia->ia_size & ~PAGE_MASK));
7702ed92554SMichael Halcrow
7712c27c65eSChristoph Hellwig if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
7722c27c65eSChristoph Hellwig truncate_setsize(inode, ia->ia_size);
7735f3ef64fSTyler Hicks lower_ia->ia_size = ia->ia_size;
7745f3ef64fSTyler Hicks lower_ia->ia_valid |= ATTR_SIZE;
77548c1e44aSAl Viro goto out;
77613a791b4STyler Hicks }
7772ed92554SMichael Halcrow if (num_zeros) {
7782ed92554SMichael Halcrow char *zeros_virt;
7792ed92554SMichael Halcrow
7802ed92554SMichael Halcrow zeros_virt = kzalloc(num_zeros, GFP_KERNEL);
7812ed92554SMichael Halcrow if (!zeros_virt) {
7822ed92554SMichael Halcrow rc = -ENOMEM;
78348c1e44aSAl Viro goto out;
784240e2df5SMichael Halcrow }
78548c1e44aSAl Viro rc = ecryptfs_write(inode, zeros_virt,
7865f3ef64fSTyler Hicks ia->ia_size, num_zeros);
7872ed92554SMichael Halcrow kfree(zeros_virt);
7885dda6992SMichael Halcrow if (rc) {
789240e2df5SMichael Halcrow printk(KERN_ERR "Error attempting to zero out "
790240e2df5SMichael Halcrow "the remainder of the end page on "
791240e2df5SMichael Halcrow "reducing truncate; rc = [%d]\n", rc);
79248c1e44aSAl Viro goto out;
793240e2df5SMichael Halcrow }
794240e2df5SMichael Halcrow }
7952c27c65eSChristoph Hellwig truncate_setsize(inode, ia->ia_size);
7960216f7f7SMichael Halcrow rc = ecryptfs_write_inode_size_to_metadata(inode);
797dd2a3b7aSMichael Halcrow if (rc) {
798dd2a3b7aSMichael Halcrow printk(KERN_ERR "Problem with "
799dd2a3b7aSMichael Halcrow "ecryptfs_write_inode_size_to_metadata; "
800dd2a3b7aSMichael Halcrow "rc = [%d]\n", rc);
80148c1e44aSAl Viro goto out;
802dd2a3b7aSMichael Halcrow }
803237fead6SMichael Halcrow /* We are reducing the size of the ecryptfs file, and need to
804237fead6SMichael Halcrow * know if we need to reduce the size of the lower file. */
805237fead6SMichael Halcrow lower_size_before_truncate =
806237fead6SMichael Halcrow upper_size_to_lower_size(crypt_stat, i_size);
807237fead6SMichael Halcrow lower_size_after_truncate =
8085f3ef64fSTyler Hicks upper_size_to_lower_size(crypt_stat, ia->ia_size);
8095f3ef64fSTyler Hicks if (lower_size_after_truncate < lower_size_before_truncate) {
8105f3ef64fSTyler Hicks lower_ia->ia_size = lower_size_after_truncate;
8115f3ef64fSTyler Hicks lower_ia->ia_valid |= ATTR_SIZE;
8125f3ef64fSTyler Hicks } else
8135f3ef64fSTyler Hicks lower_ia->ia_valid &= ~ATTR_SIZE;
814237fead6SMichael Halcrow }
815237fead6SMichael Halcrow out:
816332ab16fSTyler Hicks ecryptfs_put_lower_file(inode);
817237fead6SMichael Halcrow return rc;
818237fead6SMichael Halcrow }
819237fead6SMichael Halcrow
ecryptfs_inode_newsize_ok(struct inode * inode,loff_t offset)820a261a039STyler Hicks static int ecryptfs_inode_newsize_ok(struct inode *inode, loff_t offset)
821a261a039STyler Hicks {
822a261a039STyler Hicks struct ecryptfs_crypt_stat *crypt_stat;
823a261a039STyler Hicks loff_t lower_oldsize, lower_newsize;
824a261a039STyler Hicks
825a261a039STyler Hicks crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
826a261a039STyler Hicks lower_oldsize = upper_size_to_lower_size(crypt_stat,
827a261a039STyler Hicks i_size_read(inode));
828a261a039STyler Hicks lower_newsize = upper_size_to_lower_size(crypt_stat, offset);
829a261a039STyler Hicks if (lower_newsize > lower_oldsize) {
830a261a039STyler Hicks /*
831a261a039STyler Hicks * The eCryptfs inode and the new *lower* size are mixed here
832a261a039STyler Hicks * because we may not have the lower i_mutex held and/or it may
833a261a039STyler Hicks * not be appropriate to call inode_newsize_ok() with inodes
834a261a039STyler Hicks * from other filesystems.
835a261a039STyler Hicks */
836a261a039STyler Hicks return inode_newsize_ok(inode, lower_newsize);
837a261a039STyler Hicks }
838a261a039STyler Hicks
839a261a039STyler Hicks return 0;
840a261a039STyler Hicks }
841a261a039STyler Hicks
8425f3ef64fSTyler Hicks /**
8435f3ef64fSTyler Hicks * ecryptfs_truncate
8445f3ef64fSTyler Hicks * @dentry: The ecryptfs layer dentry
8455f3ef64fSTyler Hicks * @new_length: The length to expand the file to
8465f3ef64fSTyler Hicks *
8475f3ef64fSTyler Hicks * Simple function that handles the truncation of an eCryptfs inode and
8485f3ef64fSTyler Hicks * its corresponding lower inode.
8495f3ef64fSTyler Hicks *
8505f3ef64fSTyler Hicks * Returns zero on success; non-zero otherwise
8515f3ef64fSTyler Hicks */
ecryptfs_truncate(struct dentry * dentry,loff_t new_length)8525f3ef64fSTyler Hicks int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
8535f3ef64fSTyler Hicks {
8545f3ef64fSTyler Hicks struct iattr ia = { .ia_valid = ATTR_SIZE, .ia_size = new_length };
8555f3ef64fSTyler Hicks struct iattr lower_ia = { .ia_valid = 0 };
8565f3ef64fSTyler Hicks int rc;
8575f3ef64fSTyler Hicks
8582b0143b5SDavid Howells rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length);
859a261a039STyler Hicks if (rc)
860a261a039STyler Hicks return rc;
861a261a039STyler Hicks
8625f3ef64fSTyler Hicks rc = truncate_upper(dentry, &ia, &lower_ia);
8635f3ef64fSTyler Hicks if (!rc && lower_ia.ia_valid & ATTR_SIZE) {
8645f3ef64fSTyler Hicks struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
8655f3ef64fSTyler Hicks
8665955102cSAl Viro inode_lock(d_inode(lower_dentry));
867abf08576SChristian Brauner rc = notify_change(&nop_mnt_idmap, lower_dentry,
8682f221d6fSChristian Brauner &lower_ia, NULL);
8695955102cSAl Viro inode_unlock(d_inode(lower_dentry));
8705f3ef64fSTyler Hicks }
8715f3ef64fSTyler Hicks return rc;
8725f3ef64fSTyler Hicks }
8735f3ef64fSTyler Hicks
874237fead6SMichael Halcrow static int
ecryptfs_permission(struct mnt_idmap * idmap,struct inode * inode,int mask)8754609e1f1SChristian Brauner ecryptfs_permission(struct mnt_idmap *idmap, struct inode *inode,
876549c7297SChristian Brauner int mask)
877237fead6SMichael Halcrow {
8784609e1f1SChristian Brauner return inode_permission(&nop_mnt_idmap,
87947291baaSChristian Brauner ecryptfs_inode_to_lower(inode), mask);
880237fead6SMichael Halcrow }
881237fead6SMichael Halcrow
882237fead6SMichael Halcrow /**
883237fead6SMichael Halcrow * ecryptfs_setattr
884c1632a0fSChristian Brauner * @idmap: idmap of the target mount
885237fead6SMichael Halcrow * @dentry: dentry handle to the inode to modify
886237fead6SMichael Halcrow * @ia: Structure with flags of what to change and values
887237fead6SMichael Halcrow *
888237fead6SMichael Halcrow * Updates the metadata of an inode. If the update is to the size
889237fead6SMichael Halcrow * i.e. truncation, then ecryptfs_truncate will handle the size modification
890237fead6SMichael Halcrow * of both the ecryptfs inode and the lower inode.
891237fead6SMichael Halcrow *
892237fead6SMichael Halcrow * All other metadata changes will be passed right to the lower filesystem,
893237fead6SMichael Halcrow * and we will just update our inode to look like the lower.
894237fead6SMichael Halcrow */
ecryptfs_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * ia)895c1632a0fSChristian Brauner static int ecryptfs_setattr(struct mnt_idmap *idmap,
896549c7297SChristian Brauner struct dentry *dentry, struct iattr *ia)
897237fead6SMichael Halcrow {
898237fead6SMichael Halcrow int rc = 0;
899237fead6SMichael Halcrow struct dentry *lower_dentry;
9005f3ef64fSTyler Hicks struct iattr lower_ia;
901237fead6SMichael Halcrow struct inode *inode;
902237fead6SMichael Halcrow struct inode *lower_inode;
903237fead6SMichael Halcrow struct ecryptfs_crypt_stat *crypt_stat;
904237fead6SMichael Halcrow
9052b0143b5SDavid Howells crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
906e81f3340SHerbert Xu if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED)) {
907e81f3340SHerbert Xu rc = ecryptfs_init_crypt_stat(crypt_stat);
908e81f3340SHerbert Xu if (rc)
909e81f3340SHerbert Xu return rc;
910e81f3340SHerbert Xu }
9112b0143b5SDavid Howells inode = d_inode(dentry);
912237fead6SMichael Halcrow lower_inode = ecryptfs_inode_to_lower(inode);
913e10f281bSMichael Halcrow lower_dentry = ecryptfs_dentry_to_lower(dentry);
914e10f281bSMichael Halcrow mutex_lock(&crypt_stat->cs_mutex);
915e36cb0b8SDavid Howells if (d_is_dir(dentry))
916e10f281bSMichael Halcrow crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
917e36cb0b8SDavid Howells else if (d_is_reg(dentry)
91864ee4808SMichael Halcrow && (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)
91964ee4808SMichael Halcrow || !(crypt_stat->flags & ECRYPTFS_KEY_VALID))) {
920e10f281bSMichael Halcrow struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
921e10f281bSMichael Halcrow
922e10f281bSMichael Halcrow mount_crypt_stat = &ecryptfs_superblock_to_private(
923e10f281bSMichael Halcrow dentry->d_sb)->mount_crypt_stat;
9243b06b3ebSTyler Hicks rc = ecryptfs_get_lower_file(dentry, inode);
925332ab16fSTyler Hicks if (rc) {
926332ab16fSTyler Hicks mutex_unlock(&crypt_stat->cs_mutex);
927332ab16fSTyler Hicks goto out;
928332ab16fSTyler Hicks }
929d7cdc5feSMichael Halcrow rc = ecryptfs_read_metadata(dentry);
930332ab16fSTyler Hicks ecryptfs_put_lower_file(inode);
9315dda6992SMichael Halcrow if (rc) {
932e10f281bSMichael Halcrow if (!(mount_crypt_stat->flags
933e10f281bSMichael Halcrow & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) {
934e10f281bSMichael Halcrow rc = -EIO;
93525bd8174SMichael Halcrow printk(KERN_WARNING "Either the lower file "
936e10f281bSMichael Halcrow "is not in a valid eCryptfs format, "
93725bd8174SMichael Halcrow "or the key could not be retrieved. "
93825bd8174SMichael Halcrow "Plaintext passthrough mode is not "
939e10f281bSMichael Halcrow "enabled; returning -EIO\n");
940e10f281bSMichael Halcrow mutex_unlock(&crypt_stat->cs_mutex);
941e10f281bSMichael Halcrow goto out;
942e10f281bSMichael Halcrow }
943e10f281bSMichael Halcrow rc = 0;
9443aeb86eaSTyler Hicks crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
9453aeb86eaSTyler Hicks | ECRYPTFS_ENCRYPTED);
946e10f281bSMichael Halcrow }
947e10f281bSMichael Halcrow }
948e10f281bSMichael Halcrow mutex_unlock(&crypt_stat->cs_mutex);
949a261a039STyler Hicks
950c1632a0fSChristian Brauner rc = setattr_prepare(&nop_mnt_idmap, dentry, ia);
951a261a039STyler Hicks if (rc)
952a261a039STyler Hicks goto out;
953a261a039STyler Hicks if (ia->ia_valid & ATTR_SIZE) {
954a261a039STyler Hicks rc = ecryptfs_inode_newsize_ok(inode, ia->ia_size);
955a261a039STyler Hicks if (rc)
956a261a039STyler Hicks goto out;
957a261a039STyler Hicks }
958a261a039STyler Hicks
9595f3ef64fSTyler Hicks memcpy(&lower_ia, ia, sizeof(lower_ia));
9605f3ef64fSTyler Hicks if (ia->ia_valid & ATTR_FILE)
9615f3ef64fSTyler Hicks lower_ia.ia_file = ecryptfs_file_to_lower(ia->ia_file);
962237fead6SMichael Halcrow if (ia->ia_valid & ATTR_SIZE) {
9635f3ef64fSTyler Hicks rc = truncate_upper(dentry, ia, &lower_ia);
964237fead6SMichael Halcrow if (rc < 0)
965237fead6SMichael Halcrow goto out;
966237fead6SMichael Halcrow }
9671ac564ecSJeff Layton
9681ac564ecSJeff Layton /*
9691ac564ecSJeff Layton * mode change is for clearing setuid/setgid bits. Allow lower fs
9701ac564ecSJeff Layton * to interpret this in its own way.
9711ac564ecSJeff Layton */
9725f3ef64fSTyler Hicks if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
9735f3ef64fSTyler Hicks lower_ia.ia_valid &= ~ATTR_MODE;
9741ac564ecSJeff Layton
9755955102cSAl Viro inode_lock(d_inode(lower_dentry));
976abf08576SChristian Brauner rc = notify_change(&nop_mnt_idmap, lower_dentry, &lower_ia, NULL);
9775955102cSAl Viro inode_unlock(d_inode(lower_dentry));
978237fead6SMichael Halcrow out:
9799afa2fb6SErez Zadok fsstack_copy_attr_all(inode, lower_inode);
980237fead6SMichael Halcrow return rc;
981237fead6SMichael Halcrow }
982237fead6SMichael Halcrow
ecryptfs_getattr_link(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int flags)983b74d24f7SChristian Brauner static int ecryptfs_getattr_link(struct mnt_idmap *idmap,
984549c7297SChristian Brauner const struct path *path, struct kstat *stat,
985a528d35eSDavid Howells u32 request_mask, unsigned int flags)
9863a60a168STyler Hicks {
987a528d35eSDavid Howells struct dentry *dentry = path->dentry;
9883a60a168STyler Hicks struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
9893a60a168STyler Hicks int rc = 0;
9903a60a168STyler Hicks
9913a60a168STyler Hicks mount_crypt_stat = &ecryptfs_superblock_to_private(
9923a60a168STyler Hicks dentry->d_sb)->mount_crypt_stat;
9930d72b928SJeff Layton generic_fillattr(&nop_mnt_idmap, request_mask, d_inode(dentry), stat);
9943a60a168STyler Hicks if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
9953a60a168STyler Hicks char *target;
9963a60a168STyler Hicks size_t targetsiz;
9973a60a168STyler Hicks
998b22e8fedSAl Viro target = ecryptfs_readlink_lower(dentry, &targetsiz);
999b22e8fedSAl Viro if (!IS_ERR(target)) {
10003a60a168STyler Hicks kfree(target);
10013a60a168STyler Hicks stat->size = targetsiz;
1002b22e8fedSAl Viro } else {
1003b22e8fedSAl Viro rc = PTR_ERR(target);
10043a60a168STyler Hicks }
10053a60a168STyler Hicks }
10063a60a168STyler Hicks return rc;
10073a60a168STyler Hicks }
10083a60a168STyler Hicks
ecryptfs_do_getattr(const struct path * path,struct kstat * stat,u32 request_mask,unsigned int flags)10093fb0fa08SStefan Berger static int ecryptfs_do_getattr(const struct path *path, struct kstat *stat,
10103fb0fa08SStefan Berger u32 request_mask, unsigned int flags)
10113fb0fa08SStefan Berger {
10123fb0fa08SStefan Berger if (flags & AT_GETATTR_NOSEC)
10133fb0fa08SStefan Berger return vfs_getattr_nosec(path, stat, request_mask, flags);
10143fb0fa08SStefan Berger return vfs_getattr(path, stat, request_mask, flags);
10153fb0fa08SStefan Berger }
10163fb0fa08SStefan Berger
ecryptfs_getattr(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int flags)1017b74d24f7SChristian Brauner static int ecryptfs_getattr(struct mnt_idmap *idmap,
1018549c7297SChristian Brauner const struct path *path, struct kstat *stat,
1019a528d35eSDavid Howells u32 request_mask, unsigned int flags)
1020f8f484d1STyler Hicks {
1021a528d35eSDavid Howells struct dentry *dentry = path->dentry;
1022f8f484d1STyler Hicks struct kstat lower_stat;
1023f8f484d1STyler Hicks int rc;
1024f8f484d1STyler Hicks
10253fb0fa08SStefan Berger rc = ecryptfs_do_getattr(ecryptfs_dentry_to_lower_path(dentry),
10263fb0fa08SStefan Berger &lower_stat, request_mask, flags);
1027f8f484d1STyler Hicks if (!rc) {
10282b0143b5SDavid Howells fsstack_copy_attr_all(d_inode(dentry),
10292b0143b5SDavid Howells ecryptfs_inode_to_lower(d_inode(dentry)));
10300d72b928SJeff Layton generic_fillattr(&nop_mnt_idmap, request_mask,
10310d72b928SJeff Layton d_inode(dentry), stat);
1032f8f484d1STyler Hicks stat->blocks = lower_stat.blocks;
1033f8f484d1STyler Hicks }
1034f8f484d1STyler Hicks return rc;
1035f8f484d1STyler Hicks }
1036f8f484d1STyler Hicks
1037dd2a3b7aSMichael Halcrow int
ecryptfs_setxattr(struct dentry * dentry,struct inode * inode,const char * name,const void * value,size_t size,int flags)10383767e255SAl Viro ecryptfs_setxattr(struct dentry *dentry, struct inode *inode,
10393767e255SAl Viro const char *name, const void *value,
1040237fead6SMichael Halcrow size_t size, int flags)
1041237fead6SMichael Halcrow {
10425d6c3191SAndreas Gruenbacher int rc;
1043237fead6SMichael Halcrow struct dentry *lower_dentry;
10440b964446SMiklos Szeredi struct inode *lower_inode;
1045237fead6SMichael Halcrow
1046237fead6SMichael Halcrow lower_dentry = ecryptfs_dentry_to_lower(dentry);
10470b964446SMiklos Szeredi lower_inode = d_inode(lower_dentry);
10480b964446SMiklos Szeredi if (!(lower_inode->i_opflags & IOP_XATTR)) {
1049cfce08c6SChristian Pulvermacher rc = -EOPNOTSUPP;
1050237fead6SMichael Halcrow goto out;
1051237fead6SMichael Halcrow }
10520b964446SMiklos Szeredi inode_lock(lower_inode);
10534609e1f1SChristian Brauner rc = __vfs_setxattr_locked(&nop_mnt_idmap, lower_dentry, name, value, size, flags, NULL);
10540b964446SMiklos Szeredi inode_unlock(lower_inode);
10553767e255SAl Viro if (!rc && inode)
10560b964446SMiklos Szeredi fsstack_copy_attr_all(inode, lower_inode);
1057237fead6SMichael Halcrow out:
1058237fead6SMichael Halcrow return rc;
1059237fead6SMichael Halcrow }
1060237fead6SMichael Halcrow
1061dd2a3b7aSMichael Halcrow ssize_t
ecryptfs_getxattr_lower(struct dentry * lower_dentry,struct inode * lower_inode,const char * name,void * value,size_t size)1062ce23e640SAl Viro ecryptfs_getxattr_lower(struct dentry *lower_dentry, struct inode *lower_inode,
1063ce23e640SAl Viro const char *name, void *value, size_t size)
1064d7cdc5feSMichael Halcrow {
10655d6c3191SAndreas Gruenbacher int rc;
1066d7cdc5feSMichael Halcrow
10675d6c3191SAndreas Gruenbacher if (!(lower_inode->i_opflags & IOP_XATTR)) {
1068cfce08c6SChristian Pulvermacher rc = -EOPNOTSUPP;
1069d7cdc5feSMichael Halcrow goto out;
1070d7cdc5feSMichael Halcrow }
1071ce23e640SAl Viro inode_lock(lower_inode);
10725d6c3191SAndreas Gruenbacher rc = __vfs_getxattr(lower_dentry, lower_inode, name, value, size);
1073ce23e640SAl Viro inode_unlock(lower_inode);
1074d7cdc5feSMichael Halcrow out:
1075d7cdc5feSMichael Halcrow return rc;
1076d7cdc5feSMichael Halcrow }
1077d7cdc5feSMichael Halcrow
10787896b631SAdrian Bunk static ssize_t
ecryptfs_getxattr(struct dentry * dentry,struct inode * inode,const char * name,void * value,size_t size)1079ce23e640SAl Viro ecryptfs_getxattr(struct dentry *dentry, struct inode *inode,
1080ce23e640SAl Viro const char *name, void *value, size_t size)
1081237fead6SMichael Halcrow {
1082ce23e640SAl Viro return ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry),
1083ce23e640SAl Viro ecryptfs_inode_to_lower(inode),
1084ce23e640SAl Viro name, value, size);
1085237fead6SMichael Halcrow }
1086237fead6SMichael Halcrow
1087237fead6SMichael Halcrow static ssize_t
ecryptfs_listxattr(struct dentry * dentry,char * list,size_t size)1088237fead6SMichael Halcrow ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size)
1089237fead6SMichael Halcrow {
1090237fead6SMichael Halcrow int rc = 0;
1091237fead6SMichael Halcrow struct dentry *lower_dentry;
1092237fead6SMichael Halcrow
1093237fead6SMichael Halcrow lower_dentry = ecryptfs_dentry_to_lower(dentry);
10942b0143b5SDavid Howells if (!d_inode(lower_dentry)->i_op->listxattr) {
1095cfce08c6SChristian Pulvermacher rc = -EOPNOTSUPP;
1096237fead6SMichael Halcrow goto out;
1097237fead6SMichael Halcrow }
10985955102cSAl Viro inode_lock(d_inode(lower_dentry));
10992b0143b5SDavid Howells rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);
11005955102cSAl Viro inode_unlock(d_inode(lower_dentry));
1101237fead6SMichael Halcrow out:
1102237fead6SMichael Halcrow return rc;
1103237fead6SMichael Halcrow }
1104237fead6SMichael Halcrow
ecryptfs_removexattr(struct dentry * dentry,struct inode * inode,const char * name)11054b899da5SAndreas Gruenbacher static int ecryptfs_removexattr(struct dentry *dentry, struct inode *inode,
11064b899da5SAndreas Gruenbacher const char *name)
1107237fead6SMichael Halcrow {
11085d6c3191SAndreas Gruenbacher int rc;
1109237fead6SMichael Halcrow struct dentry *lower_dentry;
11104b899da5SAndreas Gruenbacher struct inode *lower_inode;
1111237fead6SMichael Halcrow
1112237fead6SMichael Halcrow lower_dentry = ecryptfs_dentry_to_lower(dentry);
11134b899da5SAndreas Gruenbacher lower_inode = ecryptfs_inode_to_lower(inode);
11145d6c3191SAndreas Gruenbacher if (!(lower_inode->i_opflags & IOP_XATTR)) {
1115cfce08c6SChristian Pulvermacher rc = -EOPNOTSUPP;
1116237fead6SMichael Halcrow goto out;
1117237fead6SMichael Halcrow }
11184b899da5SAndreas Gruenbacher inode_lock(lower_inode);
111939f60c1cSChristian Brauner rc = __vfs_removexattr(&nop_mnt_idmap, lower_dentry, name);
11204b899da5SAndreas Gruenbacher inode_unlock(lower_inode);
1121237fead6SMichael Halcrow out:
1122237fead6SMichael Halcrow return rc;
1123237fead6SMichael Halcrow }
1124237fead6SMichael Halcrow
ecryptfs_fileattr_get(struct dentry * dentry,struct fileattr * fa)112597e2dee9SMiklos Szeredi static int ecryptfs_fileattr_get(struct dentry *dentry, struct fileattr *fa)
112697e2dee9SMiklos Szeredi {
112797e2dee9SMiklos Szeredi return vfs_fileattr_get(ecryptfs_dentry_to_lower(dentry), fa);
112897e2dee9SMiklos Szeredi }
112997e2dee9SMiklos Szeredi
ecryptfs_fileattr_set(struct mnt_idmap * idmap,struct dentry * dentry,struct fileattr * fa)11308782a9aeSChristian Brauner static int ecryptfs_fileattr_set(struct mnt_idmap *idmap,
113197e2dee9SMiklos Szeredi struct dentry *dentry, struct fileattr *fa)
113297e2dee9SMiklos Szeredi {
113397e2dee9SMiklos Szeredi struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
113497e2dee9SMiklos Szeredi int rc;
113597e2dee9SMiklos Szeredi
11368782a9aeSChristian Brauner rc = vfs_fileattr_set(&nop_mnt_idmap, lower_dentry, fa);
113797e2dee9SMiklos Szeredi fsstack_copy_attr_all(d_inode(dentry), d_inode(lower_dentry));
113897e2dee9SMiklos Szeredi
113997e2dee9SMiklos Szeredi return rc;
114097e2dee9SMiklos Szeredi }
114197e2dee9SMiklos Szeredi
ecryptfs_get_acl(struct mnt_idmap * idmap,struct dentry * dentry,int type)114277435322SChristian Brauner static struct posix_acl *ecryptfs_get_acl(struct mnt_idmap *idmap,
1143af84016fSChristian Brauner struct dentry *dentry, int type)
1144af84016fSChristian Brauner {
114577435322SChristian Brauner return vfs_get_acl(idmap, ecryptfs_dentry_to_lower(dentry),
1146af84016fSChristian Brauner posix_acl_xattr_name(type));
1147af84016fSChristian Brauner }
1148af84016fSChristian Brauner
ecryptfs_set_acl(struct mnt_idmap * idmap,struct dentry * dentry,struct posix_acl * acl,int type)114913e83a49SChristian Brauner static int ecryptfs_set_acl(struct mnt_idmap *idmap,
115086c261b9SChristian Brauner struct dentry *dentry, struct posix_acl *acl,
115186c261b9SChristian Brauner int type)
115286c261b9SChristian Brauner {
115386c261b9SChristian Brauner int rc;
115486c261b9SChristian Brauner struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
115586c261b9SChristian Brauner struct inode *lower_inode = d_inode(lower_dentry);
115686c261b9SChristian Brauner
115713e83a49SChristian Brauner rc = vfs_set_acl(&nop_mnt_idmap, lower_dentry,
115886c261b9SChristian Brauner posix_acl_xattr_name(type), acl);
115986c261b9SChristian Brauner if (!rc)
116086c261b9SChristian Brauner fsstack_copy_attr_all(d_inode(dentry), lower_inode);
116186c261b9SChristian Brauner return rc;
116286c261b9SChristian Brauner }
116386c261b9SChristian Brauner
1164754661f1SArjan van de Ven const struct inode_operations ecryptfs_symlink_iops = {
11656b255391SAl Viro .get_link = ecryptfs_get_link,
1166237fead6SMichael Halcrow .permission = ecryptfs_permission,
1167237fead6SMichael Halcrow .setattr = ecryptfs_setattr,
11683a60a168STyler Hicks .getattr = ecryptfs_getattr_link,
1169237fead6SMichael Halcrow .listxattr = ecryptfs_listxattr,
1170237fead6SMichael Halcrow };
1171237fead6SMichael Halcrow
1172754661f1SArjan van de Ven const struct inode_operations ecryptfs_dir_iops = {
1173237fead6SMichael Halcrow .create = ecryptfs_create,
1174237fead6SMichael Halcrow .lookup = ecryptfs_lookup,
1175237fead6SMichael Halcrow .link = ecryptfs_link,
1176237fead6SMichael Halcrow .unlink = ecryptfs_unlink,
1177237fead6SMichael Halcrow .symlink = ecryptfs_symlink,
1178237fead6SMichael Halcrow .mkdir = ecryptfs_mkdir,
1179237fead6SMichael Halcrow .rmdir = ecryptfs_rmdir,
1180237fead6SMichael Halcrow .mknod = ecryptfs_mknod,
1181237fead6SMichael Halcrow .rename = ecryptfs_rename,
1182237fead6SMichael Halcrow .permission = ecryptfs_permission,
1183237fead6SMichael Halcrow .setattr = ecryptfs_setattr,
1184237fead6SMichael Halcrow .listxattr = ecryptfs_listxattr,
118597e2dee9SMiklos Szeredi .fileattr_get = ecryptfs_fileattr_get,
118697e2dee9SMiklos Szeredi .fileattr_set = ecryptfs_fileattr_set,
1187af84016fSChristian Brauner .get_acl = ecryptfs_get_acl,
118886c261b9SChristian Brauner .set_acl = ecryptfs_set_acl,
1189237fead6SMichael Halcrow };
1190237fead6SMichael Halcrow
1191754661f1SArjan van de Ven const struct inode_operations ecryptfs_main_iops = {
1192237fead6SMichael Halcrow .permission = ecryptfs_permission,
1193237fead6SMichael Halcrow .setattr = ecryptfs_setattr,
1194f8f484d1STyler Hicks .getattr = ecryptfs_getattr,
1195237fead6SMichael Halcrow .listxattr = ecryptfs_listxattr,
119697e2dee9SMiklos Szeredi .fileattr_get = ecryptfs_fileattr_get,
119797e2dee9SMiklos Szeredi .fileattr_set = ecryptfs_fileattr_set,
1198af84016fSChristian Brauner .get_acl = ecryptfs_get_acl,
119986c261b9SChristian Brauner .set_acl = ecryptfs_set_acl,
12004b899da5SAndreas Gruenbacher };
12014b899da5SAndreas Gruenbacher
ecryptfs_xattr_get(const struct xattr_handler * handler,struct dentry * dentry,struct inode * inode,const char * name,void * buffer,size_t size)12024b899da5SAndreas Gruenbacher static int ecryptfs_xattr_get(const struct xattr_handler *handler,
12034b899da5SAndreas Gruenbacher struct dentry *dentry, struct inode *inode,
12044b899da5SAndreas Gruenbacher const char *name, void *buffer, size_t size)
12054b899da5SAndreas Gruenbacher {
12064b899da5SAndreas Gruenbacher return ecryptfs_getxattr(dentry, inode, name, buffer, size);
12074b899da5SAndreas Gruenbacher }
12084b899da5SAndreas Gruenbacher
ecryptfs_xattr_set(const struct xattr_handler * handler,struct mnt_idmap * idmap,struct dentry * dentry,struct inode * inode,const char * name,const void * value,size_t size,int flags)12094b899da5SAndreas Gruenbacher static int ecryptfs_xattr_set(const struct xattr_handler *handler,
121039f60c1cSChristian Brauner struct mnt_idmap *idmap,
12114b899da5SAndreas Gruenbacher struct dentry *dentry, struct inode *inode,
12124b899da5SAndreas Gruenbacher const char *name, const void *value, size_t size,
12134b899da5SAndreas Gruenbacher int flags)
12144b899da5SAndreas Gruenbacher {
12154b899da5SAndreas Gruenbacher if (value)
12164b899da5SAndreas Gruenbacher return ecryptfs_setxattr(dentry, inode, name, value, size, flags);
12174b899da5SAndreas Gruenbacher else {
12184b899da5SAndreas Gruenbacher BUG_ON(flags != XATTR_REPLACE);
12194b899da5SAndreas Gruenbacher return ecryptfs_removexattr(dentry, inode, name);
12204b899da5SAndreas Gruenbacher }
12214b899da5SAndreas Gruenbacher }
12224b899da5SAndreas Gruenbacher
1223c036061bSYueHaibing static const struct xattr_handler ecryptfs_xattr_handler = {
12244b899da5SAndreas Gruenbacher .prefix = "", /* match anything */
12254b899da5SAndreas Gruenbacher .get = ecryptfs_xattr_get,
12264b899da5SAndreas Gruenbacher .set = ecryptfs_xattr_set,
12274b899da5SAndreas Gruenbacher };
12284b899da5SAndreas Gruenbacher
12294b899da5SAndreas Gruenbacher const struct xattr_handler *ecryptfs_xattr_handlers[] = {
12304b899da5SAndreas Gruenbacher &ecryptfs_xattr_handler,
12314b899da5SAndreas Gruenbacher NULL
1232237fead6SMichael Halcrow };
1233