xref: /linux/fs/ecryptfs/inode.c (revision 0b8061c340b643e01da431dd60c75a41bb1d31ec)
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 <mahalcro@us.ibm.com>
9  *              Michael C. Thompsion <mcthomps@us.ibm.com>
10  */
11 
12 #include <linux/file.h>
13 #include <linux/vmalloc.h>
14 #include <linux/pagemap.h>
15 #include <linux/dcache.h>
16 #include <linux/namei.h>
17 #include <linux/mount.h>
18 #include <linux/fs_stack.h>
19 #include <linux/slab.h>
20 #include <linux/xattr.h>
21 #include <asm/unaligned.h>
22 #include "ecryptfs_kernel.h"
23 
24 static struct dentry *lock_parent(struct dentry *dentry)
25 {
26 	struct dentry *dir;
27 
28 	dir = dget_parent(dentry);
29 	inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
30 	return dir;
31 }
32 
33 static void unlock_dir(struct dentry *dir)
34 {
35 	inode_unlock(d_inode(dir));
36 	dput(dir);
37 }
38 
39 static int ecryptfs_inode_test(struct inode *inode, void *lower_inode)
40 {
41 	return ecryptfs_inode_to_lower(inode) == lower_inode;
42 }
43 
44 static int ecryptfs_inode_set(struct inode *inode, void *opaque)
45 {
46 	struct inode *lower_inode = opaque;
47 
48 	ecryptfs_set_inode_lower(inode, lower_inode);
49 	fsstack_copy_attr_all(inode, lower_inode);
50 	/* i_size will be overwritten for encrypted regular files */
51 	fsstack_copy_inode_size(inode, lower_inode);
52 	inode->i_ino = lower_inode->i_ino;
53 	inode->i_mapping->a_ops = &ecryptfs_aops;
54 
55 	if (S_ISLNK(inode->i_mode))
56 		inode->i_op = &ecryptfs_symlink_iops;
57 	else if (S_ISDIR(inode->i_mode))
58 		inode->i_op = &ecryptfs_dir_iops;
59 	else
60 		inode->i_op = &ecryptfs_main_iops;
61 
62 	if (S_ISDIR(inode->i_mode))
63 		inode->i_fop = &ecryptfs_dir_fops;
64 	else if (special_file(inode->i_mode))
65 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
66 	else
67 		inode->i_fop = &ecryptfs_main_fops;
68 
69 	return 0;
70 }
71 
72 static struct inode *__ecryptfs_get_inode(struct inode *lower_inode,
73 					  struct super_block *sb)
74 {
75 	struct inode *inode;
76 
77 	if (lower_inode->i_sb != ecryptfs_superblock_to_lower(sb))
78 		return ERR_PTR(-EXDEV);
79 	if (!igrab(lower_inode))
80 		return ERR_PTR(-ESTALE);
81 	inode = iget5_locked(sb, (unsigned long)lower_inode,
82 			     ecryptfs_inode_test, ecryptfs_inode_set,
83 			     lower_inode);
84 	if (!inode) {
85 		iput(lower_inode);
86 		return ERR_PTR(-EACCES);
87 	}
88 	if (!(inode->i_state & I_NEW))
89 		iput(lower_inode);
90 
91 	return inode;
92 }
93 
94 struct inode *ecryptfs_get_inode(struct inode *lower_inode,
95 				 struct super_block *sb)
96 {
97 	struct inode *inode = __ecryptfs_get_inode(lower_inode, sb);
98 
99 	if (!IS_ERR(inode) && (inode->i_state & I_NEW))
100 		unlock_new_inode(inode);
101 
102 	return inode;
103 }
104 
105 /**
106  * ecryptfs_interpose
107  * @lower_dentry: Existing dentry in the lower filesystem
108  * @dentry: ecryptfs' dentry
109  * @sb: ecryptfs's super_block
110  *
111  * Interposes upper and lower dentries.
112  *
113  * Returns zero on success; non-zero otherwise
114  */
115 static int ecryptfs_interpose(struct dentry *lower_dentry,
116 			      struct dentry *dentry, struct super_block *sb)
117 {
118 	struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb);
119 
120 	if (IS_ERR(inode))
121 		return PTR_ERR(inode);
122 	d_instantiate(dentry, inode);
123 
124 	return 0;
125 }
126 
127 static int ecryptfs_do_unlink(struct inode *dir, struct dentry *dentry,
128 			      struct inode *inode)
129 {
130 	struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
131 	struct dentry *lower_dir_dentry;
132 	struct inode *lower_dir_inode;
133 	int rc;
134 
135 	lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);
136 	lower_dir_inode = d_inode(lower_dir_dentry);
137 	inode_lock_nested(lower_dir_inode, I_MUTEX_PARENT);
138 	dget(lower_dentry);	// don't even try to make the lower negative
139 	if (lower_dentry->d_parent != lower_dir_dentry)
140 		rc = -EINVAL;
141 	else if (d_unhashed(lower_dentry))
142 		rc = -EINVAL;
143 	else
144 		rc = vfs_unlink(&init_user_ns, lower_dir_inode, lower_dentry,
145 				NULL);
146 	if (rc) {
147 		printk(KERN_ERR "Error in vfs_unlink; rc = [%d]\n", rc);
148 		goto out_unlock;
149 	}
150 	fsstack_copy_attr_times(dir, lower_dir_inode);
151 	set_nlink(inode, ecryptfs_inode_to_lower(inode)->i_nlink);
152 	inode->i_ctime = dir->i_ctime;
153 out_unlock:
154 	dput(lower_dentry);
155 	inode_unlock(lower_dir_inode);
156 	if (!rc)
157 		d_drop(dentry);
158 	return rc;
159 }
160 
161 /**
162  * ecryptfs_do_create
163  * @directory_inode: inode of the new file's dentry's parent in ecryptfs
164  * @ecryptfs_dentry: New file's dentry in ecryptfs
165  * @mode: The mode of the new file
166  *
167  * Creates the underlying file and the eCryptfs inode which will link to
168  * it. It will also update the eCryptfs directory inode to mimic the
169  * stat of the lower directory inode.
170  *
171  * Returns the new eCryptfs inode on success; an ERR_PTR on error condition
172  */
173 static struct inode *
174 ecryptfs_do_create(struct inode *directory_inode,
175 		   struct dentry *ecryptfs_dentry, umode_t mode)
176 {
177 	int rc;
178 	struct dentry *lower_dentry;
179 	struct dentry *lower_dir_dentry;
180 	struct inode *inode;
181 
182 	lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);
183 	lower_dir_dentry = lock_parent(lower_dentry);
184 	rc = vfs_create(&init_user_ns, d_inode(lower_dir_dentry), lower_dentry,
185 			mode, true);
186 	if (rc) {
187 		printk(KERN_ERR "%s: Failure to create dentry in lower fs; "
188 		       "rc = [%d]\n", __func__, rc);
189 		inode = ERR_PTR(rc);
190 		goto out_lock;
191 	}
192 	inode = __ecryptfs_get_inode(d_inode(lower_dentry),
193 				     directory_inode->i_sb);
194 	if (IS_ERR(inode)) {
195 		vfs_unlink(&init_user_ns, d_inode(lower_dir_dentry),
196 			   lower_dentry, NULL);
197 		goto out_lock;
198 	}
199 	fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry));
200 	fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry));
201 out_lock:
202 	unlock_dir(lower_dir_dentry);
203 	return inode;
204 }
205 
206 /**
207  * ecryptfs_initialize_file
208  *
209  * Cause the file to be changed from a basic empty file to an ecryptfs
210  * file with a header and first data page.
211  *
212  * Returns zero on success
213  */
214 int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry,
215 			     struct inode *ecryptfs_inode)
216 {
217 	struct ecryptfs_crypt_stat *crypt_stat =
218 		&ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
219 	int rc = 0;
220 
221 	if (S_ISDIR(ecryptfs_inode->i_mode)) {
222 		ecryptfs_printk(KERN_DEBUG, "This is a directory\n");
223 		crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
224 		goto out;
225 	}
226 	ecryptfs_printk(KERN_DEBUG, "Initializing crypto context\n");
227 	rc = ecryptfs_new_file_context(ecryptfs_inode);
228 	if (rc) {
229 		ecryptfs_printk(KERN_ERR, "Error creating new file "
230 				"context; rc = [%d]\n", rc);
231 		goto out;
232 	}
233 	rc = ecryptfs_get_lower_file(ecryptfs_dentry, ecryptfs_inode);
234 	if (rc) {
235 		printk(KERN_ERR "%s: Error attempting to initialize "
236 			"the lower file for the dentry with name "
237 			"[%pd]; rc = [%d]\n", __func__,
238 			ecryptfs_dentry, rc);
239 		goto out;
240 	}
241 	rc = ecryptfs_write_metadata(ecryptfs_dentry, ecryptfs_inode);
242 	if (rc)
243 		printk(KERN_ERR "Error writing headers; rc = [%d]\n", rc);
244 	ecryptfs_put_lower_file(ecryptfs_inode);
245 out:
246 	return rc;
247 }
248 
249 /**
250  * ecryptfs_create
251  * @dir: The inode of the directory in which to create the file.
252  * @dentry: The eCryptfs dentry
253  * @mode: The mode of the new file.
254  *
255  * Creates a new file.
256  *
257  * Returns zero on success; non-zero on error condition
258  */
259 static int
260 ecryptfs_create(struct user_namespace *mnt_userns,
261 		struct inode *directory_inode, struct dentry *ecryptfs_dentry,
262 		umode_t mode, bool excl)
263 {
264 	struct inode *ecryptfs_inode;
265 	int rc;
266 
267 	ecryptfs_inode = ecryptfs_do_create(directory_inode, ecryptfs_dentry,
268 					    mode);
269 	if (IS_ERR(ecryptfs_inode)) {
270 		ecryptfs_printk(KERN_WARNING, "Failed to create file in"
271 				"lower filesystem\n");
272 		rc = PTR_ERR(ecryptfs_inode);
273 		goto out;
274 	}
275 	/* At this point, a file exists on "disk"; we need to make sure
276 	 * that this on disk file is prepared to be an ecryptfs file */
277 	rc = ecryptfs_initialize_file(ecryptfs_dentry, ecryptfs_inode);
278 	if (rc) {
279 		ecryptfs_do_unlink(directory_inode, ecryptfs_dentry,
280 				   ecryptfs_inode);
281 		iget_failed(ecryptfs_inode);
282 		goto out;
283 	}
284 	d_instantiate_new(ecryptfs_dentry, ecryptfs_inode);
285 out:
286 	return rc;
287 }
288 
289 static int ecryptfs_i_size_read(struct dentry *dentry, struct inode *inode)
290 {
291 	struct ecryptfs_crypt_stat *crypt_stat;
292 	int rc;
293 
294 	rc = ecryptfs_get_lower_file(dentry, inode);
295 	if (rc) {
296 		printk(KERN_ERR "%s: Error attempting to initialize "
297 			"the lower file for the dentry with name "
298 			"[%pd]; rc = [%d]\n", __func__,
299 			dentry, rc);
300 		return rc;
301 	}
302 
303 	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
304 	/* TODO: lock for crypt_stat comparison */
305 	if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED))
306 		ecryptfs_set_default_sizes(crypt_stat);
307 
308 	rc = ecryptfs_read_and_validate_header_region(inode);
309 	ecryptfs_put_lower_file(inode);
310 	if (rc) {
311 		rc = ecryptfs_read_and_validate_xattr_region(dentry, inode);
312 		if (!rc)
313 			crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;
314 	}
315 
316 	/* Must return 0 to allow non-eCryptfs files to be looked up, too */
317 	return 0;
318 }
319 
320 /**
321  * ecryptfs_lookup_interpose - Dentry interposition for a lookup
322  */
323 static struct dentry *ecryptfs_lookup_interpose(struct dentry *dentry,
324 				     struct dentry *lower_dentry)
325 {
326 	struct path *path = ecryptfs_dentry_to_lower_path(dentry->d_parent);
327 	struct inode *inode, *lower_inode;
328 	struct ecryptfs_dentry_info *dentry_info;
329 	int rc = 0;
330 
331 	dentry_info = kmem_cache_alloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
332 	if (!dentry_info) {
333 		dput(lower_dentry);
334 		return ERR_PTR(-ENOMEM);
335 	}
336 
337 	fsstack_copy_attr_atime(d_inode(dentry->d_parent),
338 				d_inode(path->dentry));
339 	BUG_ON(!d_count(lower_dentry));
340 
341 	ecryptfs_set_dentry_private(dentry, dentry_info);
342 	dentry_info->lower_path.mnt = mntget(path->mnt);
343 	dentry_info->lower_path.dentry = lower_dentry;
344 
345 	/*
346 	 * negative dentry can go positive under us here - its parent is not
347 	 * locked.  That's OK and that could happen just as we return from
348 	 * ecryptfs_lookup() anyway.  Just need to be careful and fetch
349 	 * ->d_inode only once - it's not stable here.
350 	 */
351 	lower_inode = READ_ONCE(lower_dentry->d_inode);
352 
353 	if (!lower_inode) {
354 		/* We want to add because we couldn't find in lower */
355 		d_add(dentry, NULL);
356 		return NULL;
357 	}
358 	inode = __ecryptfs_get_inode(lower_inode, dentry->d_sb);
359 	if (IS_ERR(inode)) {
360 		printk(KERN_ERR "%s: Error interposing; rc = [%ld]\n",
361 		       __func__, PTR_ERR(inode));
362 		return ERR_CAST(inode);
363 	}
364 	if (S_ISREG(inode->i_mode)) {
365 		rc = ecryptfs_i_size_read(dentry, inode);
366 		if (rc) {
367 			make_bad_inode(inode);
368 			return ERR_PTR(rc);
369 		}
370 	}
371 
372 	if (inode->i_state & I_NEW)
373 		unlock_new_inode(inode);
374 	return d_splice_alias(inode, dentry);
375 }
376 
377 /**
378  * ecryptfs_lookup
379  * @ecryptfs_dir_inode: The eCryptfs directory inode
380  * @ecryptfs_dentry: The eCryptfs dentry that we are looking up
381  * @flags: lookup flags
382  *
383  * Find a file on disk. If the file does not exist, then we'll add it to the
384  * dentry cache and continue on to read it from the disk.
385  */
386 static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
387 				      struct dentry *ecryptfs_dentry,
388 				      unsigned int flags)
389 {
390 	char *encrypted_and_encoded_name = NULL;
391 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
392 	struct dentry *lower_dir_dentry, *lower_dentry;
393 	const char *name = ecryptfs_dentry->d_name.name;
394 	size_t len = ecryptfs_dentry->d_name.len;
395 	struct dentry *res;
396 	int rc = 0;
397 
398 	lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
399 
400 	mount_crypt_stat = &ecryptfs_superblock_to_private(
401 				ecryptfs_dentry->d_sb)->mount_crypt_stat;
402 	if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
403 		rc = ecryptfs_encrypt_and_encode_filename(
404 			&encrypted_and_encoded_name, &len,
405 			mount_crypt_stat, name, len);
406 		if (rc) {
407 			printk(KERN_ERR "%s: Error attempting to encrypt and encode "
408 			       "filename; rc = [%d]\n", __func__, rc);
409 			return ERR_PTR(rc);
410 		}
411 		name = encrypted_and_encoded_name;
412 	}
413 
414 	lower_dentry = lookup_one_len_unlocked(name, lower_dir_dentry, len);
415 	if (IS_ERR(lower_dentry)) {
416 		ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
417 				"[%ld] on lower_dentry = [%s]\n", __func__,
418 				PTR_ERR(lower_dentry),
419 				name);
420 		res = ERR_CAST(lower_dentry);
421 	} else {
422 		res = ecryptfs_lookup_interpose(ecryptfs_dentry, lower_dentry);
423 	}
424 	kfree(encrypted_and_encoded_name);
425 	return res;
426 }
427 
428 static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,
429 			 struct dentry *new_dentry)
430 {
431 	struct dentry *lower_old_dentry;
432 	struct dentry *lower_new_dentry;
433 	struct dentry *lower_dir_dentry;
434 	u64 file_size_save;
435 	int rc;
436 
437 	file_size_save = i_size_read(d_inode(old_dentry));
438 	lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
439 	lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
440 	dget(lower_old_dentry);
441 	dget(lower_new_dentry);
442 	lower_dir_dentry = lock_parent(lower_new_dentry);
443 	rc = vfs_link(lower_old_dentry, &init_user_ns,
444 		      d_inode(lower_dir_dentry), lower_new_dentry, NULL);
445 	if (rc || d_really_is_negative(lower_new_dentry))
446 		goto out_lock;
447 	rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);
448 	if (rc)
449 		goto out_lock;
450 	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
451 	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
452 	set_nlink(d_inode(old_dentry),
453 		  ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink);
454 	i_size_write(d_inode(new_dentry), file_size_save);
455 out_lock:
456 	unlock_dir(lower_dir_dentry);
457 	dput(lower_new_dentry);
458 	dput(lower_old_dentry);
459 	return rc;
460 }
461 
462 static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
463 {
464 	return ecryptfs_do_unlink(dir, dentry, d_inode(dentry));
465 }
466 
467 static int ecryptfs_symlink(struct user_namespace *mnt_userns,
468 			    struct inode *dir, struct dentry *dentry,
469 			    const char *symname)
470 {
471 	int rc;
472 	struct dentry *lower_dentry;
473 	struct dentry *lower_dir_dentry;
474 	char *encoded_symname;
475 	size_t encoded_symlen;
476 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat = NULL;
477 
478 	lower_dentry = ecryptfs_dentry_to_lower(dentry);
479 	dget(lower_dentry);
480 	lower_dir_dentry = lock_parent(lower_dentry);
481 	mount_crypt_stat = &ecryptfs_superblock_to_private(
482 		dir->i_sb)->mount_crypt_stat;
483 	rc = ecryptfs_encrypt_and_encode_filename(&encoded_symname,
484 						  &encoded_symlen,
485 						  mount_crypt_stat, symname,
486 						  strlen(symname));
487 	if (rc)
488 		goto out_lock;
489 	rc = vfs_symlink(&init_user_ns, d_inode(lower_dir_dentry), lower_dentry,
490 			 encoded_symname);
491 	kfree(encoded_symname);
492 	if (rc || d_really_is_negative(lower_dentry))
493 		goto out_lock;
494 	rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
495 	if (rc)
496 		goto out_lock;
497 	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
498 	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
499 out_lock:
500 	unlock_dir(lower_dir_dentry);
501 	dput(lower_dentry);
502 	if (d_really_is_negative(dentry))
503 		d_drop(dentry);
504 	return rc;
505 }
506 
507 static int ecryptfs_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
508 			  struct dentry *dentry, umode_t mode)
509 {
510 	int rc;
511 	struct dentry *lower_dentry;
512 	struct dentry *lower_dir_dentry;
513 
514 	lower_dentry = ecryptfs_dentry_to_lower(dentry);
515 	lower_dir_dentry = lock_parent(lower_dentry);
516 	rc = vfs_mkdir(&init_user_ns, d_inode(lower_dir_dentry), lower_dentry,
517 		       mode);
518 	if (rc || d_really_is_negative(lower_dentry))
519 		goto out;
520 	rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
521 	if (rc)
522 		goto out;
523 	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
524 	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
525 	set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink);
526 out:
527 	unlock_dir(lower_dir_dentry);
528 	if (d_really_is_negative(dentry))
529 		d_drop(dentry);
530 	return rc;
531 }
532 
533 static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry)
534 {
535 	struct dentry *lower_dentry;
536 	struct dentry *lower_dir_dentry;
537 	struct inode *lower_dir_inode;
538 	int rc;
539 
540 	lower_dentry = ecryptfs_dentry_to_lower(dentry);
541 	lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);
542 	lower_dir_inode = d_inode(lower_dir_dentry);
543 
544 	inode_lock_nested(lower_dir_inode, I_MUTEX_PARENT);
545 	dget(lower_dentry);	// don't even try to make the lower negative
546 	if (lower_dentry->d_parent != lower_dir_dentry)
547 		rc = -EINVAL;
548 	else if (d_unhashed(lower_dentry))
549 		rc = -EINVAL;
550 	else
551 		rc = vfs_rmdir(&init_user_ns, lower_dir_inode, lower_dentry);
552 	if (!rc) {
553 		clear_nlink(d_inode(dentry));
554 		fsstack_copy_attr_times(dir, lower_dir_inode);
555 		set_nlink(dir, lower_dir_inode->i_nlink);
556 	}
557 	dput(lower_dentry);
558 	inode_unlock(lower_dir_inode);
559 	if (!rc)
560 		d_drop(dentry);
561 	return rc;
562 }
563 
564 static int
565 ecryptfs_mknod(struct user_namespace *mnt_userns, struct inode *dir,
566 	       struct dentry *dentry, umode_t mode, dev_t dev)
567 {
568 	int rc;
569 	struct dentry *lower_dentry;
570 	struct dentry *lower_dir_dentry;
571 
572 	lower_dentry = ecryptfs_dentry_to_lower(dentry);
573 	lower_dir_dentry = lock_parent(lower_dentry);
574 	rc = vfs_mknod(&init_user_ns, d_inode(lower_dir_dentry), lower_dentry,
575 		       mode, dev);
576 	if (rc || d_really_is_negative(lower_dentry))
577 		goto out;
578 	rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);
579 	if (rc)
580 		goto out;
581 	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));
582 	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));
583 out:
584 	unlock_dir(lower_dir_dentry);
585 	if (d_really_is_negative(dentry))
586 		d_drop(dentry);
587 	return rc;
588 }
589 
590 static int
591 ecryptfs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
592 		struct dentry *old_dentry, struct inode *new_dir,
593 		struct dentry *new_dentry, unsigned int flags)
594 {
595 	int rc;
596 	struct dentry *lower_old_dentry;
597 	struct dentry *lower_new_dentry;
598 	struct dentry *lower_old_dir_dentry;
599 	struct dentry *lower_new_dir_dentry;
600 	struct dentry *trap;
601 	struct inode *target_inode;
602 	struct renamedata rd = {};
603 
604 	if (flags)
605 		return -EINVAL;
606 
607 	lower_old_dir_dentry = ecryptfs_dentry_to_lower(old_dentry->d_parent);
608 	lower_new_dir_dentry = ecryptfs_dentry_to_lower(new_dentry->d_parent);
609 
610 	lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
611 	lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
612 
613 	target_inode = d_inode(new_dentry);
614 
615 	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
616 	dget(lower_new_dentry);
617 	rc = -EINVAL;
618 	if (lower_old_dentry->d_parent != lower_old_dir_dentry)
619 		goto out_lock;
620 	if (lower_new_dentry->d_parent != lower_new_dir_dentry)
621 		goto out_lock;
622 	if (d_unhashed(lower_old_dentry) || d_unhashed(lower_new_dentry))
623 		goto out_lock;
624 	/* source should not be ancestor of target */
625 	if (trap == lower_old_dentry)
626 		goto out_lock;
627 	/* target should not be ancestor of source */
628 	if (trap == lower_new_dentry) {
629 		rc = -ENOTEMPTY;
630 		goto out_lock;
631 	}
632 
633 	rd.old_mnt_userns	= &init_user_ns;
634 	rd.old_dir		= d_inode(lower_old_dir_dentry);
635 	rd.old_dentry		= lower_old_dentry;
636 	rd.new_mnt_userns	= &init_user_ns;
637 	rd.new_dir		= d_inode(lower_new_dir_dentry);
638 	rd.new_dentry		= lower_new_dentry;
639 	rc = vfs_rename(&rd);
640 	if (rc)
641 		goto out_lock;
642 	if (target_inode)
643 		fsstack_copy_attr_all(target_inode,
644 				      ecryptfs_inode_to_lower(target_inode));
645 	fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));
646 	if (new_dir != old_dir)
647 		fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));
648 out_lock:
649 	dput(lower_new_dentry);
650 	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
651 	return rc;
652 }
653 
654 static char *ecryptfs_readlink_lower(struct dentry *dentry, size_t *bufsiz)
655 {
656 	DEFINE_DELAYED_CALL(done);
657 	struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
658 	const char *link;
659 	char *buf;
660 	int rc;
661 
662 	link = vfs_get_link(lower_dentry, &done);
663 	if (IS_ERR(link))
664 		return ERR_CAST(link);
665 
666 	rc = ecryptfs_decode_and_decrypt_filename(&buf, bufsiz, dentry->d_sb,
667 						  link, strlen(link));
668 	do_delayed_call(&done);
669 	if (rc)
670 		return ERR_PTR(rc);
671 
672 	return buf;
673 }
674 
675 static const char *ecryptfs_get_link(struct dentry *dentry,
676 				     struct inode *inode,
677 				     struct delayed_call *done)
678 {
679 	size_t len;
680 	char *buf;
681 
682 	if (!dentry)
683 		return ERR_PTR(-ECHILD);
684 
685 	buf = ecryptfs_readlink_lower(dentry, &len);
686 	if (IS_ERR(buf))
687 		return buf;
688 	fsstack_copy_attr_atime(d_inode(dentry),
689 				d_inode(ecryptfs_dentry_to_lower(dentry)));
690 	buf[len] = '\0';
691 	set_delayed_call(done, kfree_link, buf);
692 	return buf;
693 }
694 
695 /**
696  * upper_size_to_lower_size
697  * @crypt_stat: Crypt_stat associated with file
698  * @upper_size: Size of the upper file
699  *
700  * Calculate the required size of the lower file based on the
701  * specified size of the upper file. This calculation is based on the
702  * number of headers in the underlying file and the extent size.
703  *
704  * Returns Calculated size of the lower file.
705  */
706 static loff_t
707 upper_size_to_lower_size(struct ecryptfs_crypt_stat *crypt_stat,
708 			 loff_t upper_size)
709 {
710 	loff_t lower_size;
711 
712 	lower_size = ecryptfs_lower_header_size(crypt_stat);
713 	if (upper_size != 0) {
714 		loff_t num_extents;
715 
716 		num_extents = upper_size >> crypt_stat->extent_shift;
717 		if (upper_size & ~crypt_stat->extent_mask)
718 			num_extents++;
719 		lower_size += (num_extents * crypt_stat->extent_size);
720 	}
721 	return lower_size;
722 }
723 
724 /**
725  * truncate_upper
726  * @dentry: The ecryptfs layer dentry
727  * @ia: Address of the ecryptfs inode's attributes
728  * @lower_ia: Address of the lower inode's attributes
729  *
730  * Function to handle truncations modifying the size of the file. Note
731  * that the file sizes are interpolated. When expanding, we are simply
732  * writing strings of 0's out. When truncating, we truncate the upper
733  * inode and update the lower_ia according to the page index
734  * interpolations. If ATTR_SIZE is set in lower_ia->ia_valid upon return,
735  * the caller must use lower_ia in a call to notify_change() to perform
736  * the truncation of the lower inode.
737  *
738  * Returns zero on success; non-zero otherwise
739  */
740 static int truncate_upper(struct dentry *dentry, struct iattr *ia,
741 			  struct iattr *lower_ia)
742 {
743 	int rc = 0;
744 	struct inode *inode = d_inode(dentry);
745 	struct ecryptfs_crypt_stat *crypt_stat;
746 	loff_t i_size = i_size_read(inode);
747 	loff_t lower_size_before_truncate;
748 	loff_t lower_size_after_truncate;
749 
750 	if (unlikely((ia->ia_size == i_size))) {
751 		lower_ia->ia_valid &= ~ATTR_SIZE;
752 		return 0;
753 	}
754 	rc = ecryptfs_get_lower_file(dentry, inode);
755 	if (rc)
756 		return rc;
757 	crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
758 	/* Switch on growing or shrinking file */
759 	if (ia->ia_size > i_size) {
760 		char zero[] = { 0x00 };
761 
762 		lower_ia->ia_valid &= ~ATTR_SIZE;
763 		/* Write a single 0 at the last position of the file;
764 		 * this triggers code that will fill in 0's throughout
765 		 * the intermediate portion of the previous end of the
766 		 * file and the new and of the file */
767 		rc = ecryptfs_write(inode, zero,
768 				    (ia->ia_size - 1), 1);
769 	} else { /* ia->ia_size < i_size_read(inode) */
770 		/* We're chopping off all the pages down to the page
771 		 * in which ia->ia_size is located. Fill in the end of
772 		 * that page from (ia->ia_size & ~PAGE_MASK) to
773 		 * PAGE_SIZE with zeros. */
774 		size_t num_zeros = (PAGE_SIZE
775 				    - (ia->ia_size & ~PAGE_MASK));
776 
777 		if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
778 			truncate_setsize(inode, ia->ia_size);
779 			lower_ia->ia_size = ia->ia_size;
780 			lower_ia->ia_valid |= ATTR_SIZE;
781 			goto out;
782 		}
783 		if (num_zeros) {
784 			char *zeros_virt;
785 
786 			zeros_virt = kzalloc(num_zeros, GFP_KERNEL);
787 			if (!zeros_virt) {
788 				rc = -ENOMEM;
789 				goto out;
790 			}
791 			rc = ecryptfs_write(inode, zeros_virt,
792 					    ia->ia_size, num_zeros);
793 			kfree(zeros_virt);
794 			if (rc) {
795 				printk(KERN_ERR "Error attempting to zero out "
796 				       "the remainder of the end page on "
797 				       "reducing truncate; rc = [%d]\n", rc);
798 				goto out;
799 			}
800 		}
801 		truncate_setsize(inode, ia->ia_size);
802 		rc = ecryptfs_write_inode_size_to_metadata(inode);
803 		if (rc) {
804 			printk(KERN_ERR	"Problem with "
805 			       "ecryptfs_write_inode_size_to_metadata; "
806 			       "rc = [%d]\n", rc);
807 			goto out;
808 		}
809 		/* We are reducing the size of the ecryptfs file, and need to
810 		 * know if we need to reduce the size of the lower file. */
811 		lower_size_before_truncate =
812 		    upper_size_to_lower_size(crypt_stat, i_size);
813 		lower_size_after_truncate =
814 		    upper_size_to_lower_size(crypt_stat, ia->ia_size);
815 		if (lower_size_after_truncate < lower_size_before_truncate) {
816 			lower_ia->ia_size = lower_size_after_truncate;
817 			lower_ia->ia_valid |= ATTR_SIZE;
818 		} else
819 			lower_ia->ia_valid &= ~ATTR_SIZE;
820 	}
821 out:
822 	ecryptfs_put_lower_file(inode);
823 	return rc;
824 }
825 
826 static int ecryptfs_inode_newsize_ok(struct inode *inode, loff_t offset)
827 {
828 	struct ecryptfs_crypt_stat *crypt_stat;
829 	loff_t lower_oldsize, lower_newsize;
830 
831 	crypt_stat = &ecryptfs_inode_to_private(inode)->crypt_stat;
832 	lower_oldsize = upper_size_to_lower_size(crypt_stat,
833 						 i_size_read(inode));
834 	lower_newsize = upper_size_to_lower_size(crypt_stat, offset);
835 	if (lower_newsize > lower_oldsize) {
836 		/*
837 		 * The eCryptfs inode and the new *lower* size are mixed here
838 		 * because we may not have the lower i_mutex held and/or it may
839 		 * not be appropriate to call inode_newsize_ok() with inodes
840 		 * from other filesystems.
841 		 */
842 		return inode_newsize_ok(inode, lower_newsize);
843 	}
844 
845 	return 0;
846 }
847 
848 /**
849  * ecryptfs_truncate
850  * @dentry: The ecryptfs layer dentry
851  * @new_length: The length to expand the file to
852  *
853  * Simple function that handles the truncation of an eCryptfs inode and
854  * its corresponding lower inode.
855  *
856  * Returns zero on success; non-zero otherwise
857  */
858 int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
859 {
860 	struct iattr ia = { .ia_valid = ATTR_SIZE, .ia_size = new_length };
861 	struct iattr lower_ia = { .ia_valid = 0 };
862 	int rc;
863 
864 	rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length);
865 	if (rc)
866 		return rc;
867 
868 	rc = truncate_upper(dentry, &ia, &lower_ia);
869 	if (!rc && lower_ia.ia_valid & ATTR_SIZE) {
870 		struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
871 
872 		inode_lock(d_inode(lower_dentry));
873 		rc = notify_change(&init_user_ns, lower_dentry,
874 				   &lower_ia, NULL);
875 		inode_unlock(d_inode(lower_dentry));
876 	}
877 	return rc;
878 }
879 
880 static int
881 ecryptfs_permission(struct user_namespace *mnt_userns, struct inode *inode,
882 		    int mask)
883 {
884 	return inode_permission(&init_user_ns,
885 				ecryptfs_inode_to_lower(inode), mask);
886 }
887 
888 /**
889  * ecryptfs_setattr
890  * @dentry: dentry handle to the inode to modify
891  * @ia: Structure with flags of what to change and values
892  *
893  * Updates the metadata of an inode. If the update is to the size
894  * i.e. truncation, then ecryptfs_truncate will handle the size modification
895  * of both the ecryptfs inode and the lower inode.
896  *
897  * All other metadata changes will be passed right to the lower filesystem,
898  * and we will just update our inode to look like the lower.
899  */
900 static int ecryptfs_setattr(struct user_namespace *mnt_userns,
901 			    struct dentry *dentry, struct iattr *ia)
902 {
903 	int rc = 0;
904 	struct dentry *lower_dentry;
905 	struct iattr lower_ia;
906 	struct inode *inode;
907 	struct inode *lower_inode;
908 	struct ecryptfs_crypt_stat *crypt_stat;
909 
910 	crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat;
911 	if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED)) {
912 		rc = ecryptfs_init_crypt_stat(crypt_stat);
913 		if (rc)
914 			return rc;
915 	}
916 	inode = d_inode(dentry);
917 	lower_inode = ecryptfs_inode_to_lower(inode);
918 	lower_dentry = ecryptfs_dentry_to_lower(dentry);
919 	mutex_lock(&crypt_stat->cs_mutex);
920 	if (d_is_dir(dentry))
921 		crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
922 	else if (d_is_reg(dentry)
923 		 && (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)
924 		     || !(crypt_stat->flags & ECRYPTFS_KEY_VALID))) {
925 		struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
926 
927 		mount_crypt_stat = &ecryptfs_superblock_to_private(
928 			dentry->d_sb)->mount_crypt_stat;
929 		rc = ecryptfs_get_lower_file(dentry, inode);
930 		if (rc) {
931 			mutex_unlock(&crypt_stat->cs_mutex);
932 			goto out;
933 		}
934 		rc = ecryptfs_read_metadata(dentry);
935 		ecryptfs_put_lower_file(inode);
936 		if (rc) {
937 			if (!(mount_crypt_stat->flags
938 			      & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) {
939 				rc = -EIO;
940 				printk(KERN_WARNING "Either the lower file "
941 				       "is not in a valid eCryptfs format, "
942 				       "or the key could not be retrieved. "
943 				       "Plaintext passthrough mode is not "
944 				       "enabled; returning -EIO\n");
945 				mutex_unlock(&crypt_stat->cs_mutex);
946 				goto out;
947 			}
948 			rc = 0;
949 			crypt_stat->flags &= ~(ECRYPTFS_I_SIZE_INITIALIZED
950 					       | ECRYPTFS_ENCRYPTED);
951 		}
952 	}
953 	mutex_unlock(&crypt_stat->cs_mutex);
954 
955 	rc = setattr_prepare(&init_user_ns, dentry, ia);
956 	if (rc)
957 		goto out;
958 	if (ia->ia_valid & ATTR_SIZE) {
959 		rc = ecryptfs_inode_newsize_ok(inode, ia->ia_size);
960 		if (rc)
961 			goto out;
962 	}
963 
964 	memcpy(&lower_ia, ia, sizeof(lower_ia));
965 	if (ia->ia_valid & ATTR_FILE)
966 		lower_ia.ia_file = ecryptfs_file_to_lower(ia->ia_file);
967 	if (ia->ia_valid & ATTR_SIZE) {
968 		rc = truncate_upper(dentry, ia, &lower_ia);
969 		if (rc < 0)
970 			goto out;
971 	}
972 
973 	/*
974 	 * mode change is for clearing setuid/setgid bits. Allow lower fs
975 	 * to interpret this in its own way.
976 	 */
977 	if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
978 		lower_ia.ia_valid &= ~ATTR_MODE;
979 
980 	inode_lock(d_inode(lower_dentry));
981 	rc = notify_change(&init_user_ns, lower_dentry, &lower_ia, NULL);
982 	inode_unlock(d_inode(lower_dentry));
983 out:
984 	fsstack_copy_attr_all(inode, lower_inode);
985 	return rc;
986 }
987 
988 static int ecryptfs_getattr_link(struct user_namespace *mnt_userns,
989 				 const struct path *path, struct kstat *stat,
990 				 u32 request_mask, unsigned int flags)
991 {
992 	struct dentry *dentry = path->dentry;
993 	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
994 	int rc = 0;
995 
996 	mount_crypt_stat = &ecryptfs_superblock_to_private(
997 						dentry->d_sb)->mount_crypt_stat;
998 	generic_fillattr(&init_user_ns, d_inode(dentry), stat);
999 	if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) {
1000 		char *target;
1001 		size_t targetsiz;
1002 
1003 		target = ecryptfs_readlink_lower(dentry, &targetsiz);
1004 		if (!IS_ERR(target)) {
1005 			kfree(target);
1006 			stat->size = targetsiz;
1007 		} else {
1008 			rc = PTR_ERR(target);
1009 		}
1010 	}
1011 	return rc;
1012 }
1013 
1014 static int ecryptfs_getattr(struct user_namespace *mnt_userns,
1015 			    const struct path *path, struct kstat *stat,
1016 			    u32 request_mask, unsigned int flags)
1017 {
1018 	struct dentry *dentry = path->dentry;
1019 	struct kstat lower_stat;
1020 	int rc;
1021 
1022 	rc = vfs_getattr(ecryptfs_dentry_to_lower_path(dentry), &lower_stat,
1023 			 request_mask, flags);
1024 	if (!rc) {
1025 		fsstack_copy_attr_all(d_inode(dentry),
1026 				      ecryptfs_inode_to_lower(d_inode(dentry)));
1027 		generic_fillattr(&init_user_ns, d_inode(dentry), stat);
1028 		stat->blocks = lower_stat.blocks;
1029 	}
1030 	return rc;
1031 }
1032 
1033 int
1034 ecryptfs_setxattr(struct dentry *dentry, struct inode *inode,
1035 		  const char *name, const void *value,
1036 		  size_t size, int flags)
1037 {
1038 	int rc;
1039 	struct dentry *lower_dentry;
1040 	struct inode *lower_inode;
1041 
1042 	lower_dentry = ecryptfs_dentry_to_lower(dentry);
1043 	lower_inode = d_inode(lower_dentry);
1044 	if (!(lower_inode->i_opflags & IOP_XATTR)) {
1045 		rc = -EOPNOTSUPP;
1046 		goto out;
1047 	}
1048 	inode_lock(lower_inode);
1049 	rc = __vfs_setxattr_locked(&init_user_ns, lower_dentry, name, value, size, flags, NULL);
1050 	inode_unlock(lower_inode);
1051 	if (!rc && inode)
1052 		fsstack_copy_attr_all(inode, lower_inode);
1053 out:
1054 	return rc;
1055 }
1056 
1057 ssize_t
1058 ecryptfs_getxattr_lower(struct dentry *lower_dentry, struct inode *lower_inode,
1059 			const char *name, void *value, size_t size)
1060 {
1061 	int rc;
1062 
1063 	if (!(lower_inode->i_opflags & IOP_XATTR)) {
1064 		rc = -EOPNOTSUPP;
1065 		goto out;
1066 	}
1067 	inode_lock(lower_inode);
1068 	rc = __vfs_getxattr(lower_dentry, lower_inode, name, value, size);
1069 	inode_unlock(lower_inode);
1070 out:
1071 	return rc;
1072 }
1073 
1074 static ssize_t
1075 ecryptfs_getxattr(struct dentry *dentry, struct inode *inode,
1076 		  const char *name, void *value, size_t size)
1077 {
1078 	return ecryptfs_getxattr_lower(ecryptfs_dentry_to_lower(dentry),
1079 				       ecryptfs_inode_to_lower(inode),
1080 				       name, value, size);
1081 }
1082 
1083 static ssize_t
1084 ecryptfs_listxattr(struct dentry *dentry, char *list, size_t size)
1085 {
1086 	int rc = 0;
1087 	struct dentry *lower_dentry;
1088 
1089 	lower_dentry = ecryptfs_dentry_to_lower(dentry);
1090 	if (!d_inode(lower_dentry)->i_op->listxattr) {
1091 		rc = -EOPNOTSUPP;
1092 		goto out;
1093 	}
1094 	inode_lock(d_inode(lower_dentry));
1095 	rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size);
1096 	inode_unlock(d_inode(lower_dentry));
1097 out:
1098 	return rc;
1099 }
1100 
1101 static int ecryptfs_removexattr(struct dentry *dentry, struct inode *inode,
1102 				const char *name)
1103 {
1104 	int rc;
1105 	struct dentry *lower_dentry;
1106 	struct inode *lower_inode;
1107 
1108 	lower_dentry = ecryptfs_dentry_to_lower(dentry);
1109 	lower_inode = ecryptfs_inode_to_lower(inode);
1110 	if (!(lower_inode->i_opflags & IOP_XATTR)) {
1111 		rc = -EOPNOTSUPP;
1112 		goto out;
1113 	}
1114 	inode_lock(lower_inode);
1115 	rc = __vfs_removexattr(&init_user_ns, lower_dentry, name);
1116 	inode_unlock(lower_inode);
1117 out:
1118 	return rc;
1119 }
1120 
1121 const struct inode_operations ecryptfs_symlink_iops = {
1122 	.get_link = ecryptfs_get_link,
1123 	.permission = ecryptfs_permission,
1124 	.setattr = ecryptfs_setattr,
1125 	.getattr = ecryptfs_getattr_link,
1126 	.listxattr = ecryptfs_listxattr,
1127 };
1128 
1129 const struct inode_operations ecryptfs_dir_iops = {
1130 	.create = ecryptfs_create,
1131 	.lookup = ecryptfs_lookup,
1132 	.link = ecryptfs_link,
1133 	.unlink = ecryptfs_unlink,
1134 	.symlink = ecryptfs_symlink,
1135 	.mkdir = ecryptfs_mkdir,
1136 	.rmdir = ecryptfs_rmdir,
1137 	.mknod = ecryptfs_mknod,
1138 	.rename = ecryptfs_rename,
1139 	.permission = ecryptfs_permission,
1140 	.setattr = ecryptfs_setattr,
1141 	.listxattr = ecryptfs_listxattr,
1142 };
1143 
1144 const struct inode_operations ecryptfs_main_iops = {
1145 	.permission = ecryptfs_permission,
1146 	.setattr = ecryptfs_setattr,
1147 	.getattr = ecryptfs_getattr,
1148 	.listxattr = ecryptfs_listxattr,
1149 };
1150 
1151 static int ecryptfs_xattr_get(const struct xattr_handler *handler,
1152 			      struct dentry *dentry, struct inode *inode,
1153 			      const char *name, void *buffer, size_t size)
1154 {
1155 	return ecryptfs_getxattr(dentry, inode, name, buffer, size);
1156 }
1157 
1158 static int ecryptfs_xattr_set(const struct xattr_handler *handler,
1159 			      struct user_namespace *mnt_userns,
1160 			      struct dentry *dentry, struct inode *inode,
1161 			      const char *name, const void *value, size_t size,
1162 			      int flags)
1163 {
1164 	if (value)
1165 		return ecryptfs_setxattr(dentry, inode, name, value, size, flags);
1166 	else {
1167 		BUG_ON(flags != XATTR_REPLACE);
1168 		return ecryptfs_removexattr(dentry, inode, name);
1169 	}
1170 }
1171 
1172 static const struct xattr_handler ecryptfs_xattr_handler = {
1173 	.prefix = "",  /* match anything */
1174 	.get = ecryptfs_xattr_get,
1175 	.set = ecryptfs_xattr_set,
1176 };
1177 
1178 const struct xattr_handler *ecryptfs_xattr_handlers[] = {
1179 	&ecryptfs_xattr_handler,
1180 	NULL
1181 };
1182