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