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