2 * eCryptfs: Linux filesystem encryption layer
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>
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.
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.
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
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 "ecryptfs_kernel.h"
36 static struct dentry
*lock_parent(struct dentry
*dentry
)
40 dir
= dget(dentry
->d_parent
);
41 mutex_lock_nested(&(dir
->d_inode
->i_mutex
), I_MUTEX_PARENT
);
45 static void unlock_parent(struct dentry
*dentry
)
47 mutex_unlock(&(dentry
->d_parent
->d_inode
->i_mutex
));
48 dput(dentry
->d_parent
);
51 static void unlock_dir(struct dentry
*dir
)
53 mutex_unlock(&dir
->d_inode
->i_mutex
);
58 * ecryptfs_create_underlying_file
59 * @lower_dir_inode: inode of the parent in the lower fs of the new file
60 * @lower_dentry: New file's dentry in the lower fs
61 * @ecryptfs_dentry: New file's dentry in ecryptfs
62 * @mode: The mode of the new file
63 * @nd: nameidata of ecryptfs' parent's dentry & vfsmount
65 * Creates the file in the lower file system.
67 * Returns zero on success; non-zero on error condition
70 ecryptfs_create_underlying_file(struct inode
*lower_dir_inode
,
71 struct dentry
*dentry
, int mode
,
74 struct dentry
*lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
75 struct vfsmount
*lower_mnt
= ecryptfs_dentry_to_lower_mnt(dentry
);
76 struct dentry
*dentry_save
;
77 struct vfsmount
*vfsmount_save
;
80 dentry_save
= nd
->dentry
;
81 vfsmount_save
= nd
->mnt
;
82 nd
->dentry
= lower_dentry
;
84 rc
= vfs_create(lower_dir_inode
, lower_dentry
, mode
, nd
);
85 nd
->dentry
= dentry_save
;
86 nd
->mnt
= vfsmount_save
;
92 * @directory_inode: inode of the new file's dentry's parent in ecryptfs
93 * @ecryptfs_dentry: New file's dentry in ecryptfs
94 * @mode: The mode of the new file
95 * @nd: nameidata of ecryptfs' parent's dentry & vfsmount
97 * Creates the underlying file and the eCryptfs inode which will link to
98 * it. It will also update the eCryptfs directory inode to mimic the
99 * stat of the lower directory inode.
101 * Returns zero on success; non-zero on error condition
104 ecryptfs_do_create(struct inode
*directory_inode
,
105 struct dentry
*ecryptfs_dentry
, int mode
,
106 struct nameidata
*nd
)
109 struct dentry
*lower_dentry
;
110 struct dentry
*lower_dir_dentry
;
112 lower_dentry
= ecryptfs_dentry_to_lower(ecryptfs_dentry
);
113 lower_dir_dentry
= lock_parent(lower_dentry
);
114 if (unlikely(IS_ERR(lower_dir_dentry
))) {
115 ecryptfs_printk(KERN_ERR
, "Error locking directory of "
117 rc
= PTR_ERR(lower_dir_dentry
);
120 rc
= ecryptfs_create_underlying_file(lower_dir_dentry
->d_inode
,
121 ecryptfs_dentry
, mode
, nd
);
123 ecryptfs_printk(KERN_ERR
,
124 "Failure to create underlying file\n");
127 rc
= ecryptfs_interpose(lower_dentry
, ecryptfs_dentry
,
128 directory_inode
->i_sb
, 0);
130 ecryptfs_printk(KERN_ERR
, "Failure in ecryptfs_interpose\n");
133 fsstack_copy_attr_times(directory_inode
, lower_dir_dentry
->d_inode
);
134 fsstack_copy_inode_size(directory_inode
, lower_dir_dentry
->d_inode
);
136 unlock_dir(lower_dir_dentry
);
143 * @ecryptfs_dentry: the ecryptfs dentry
144 * @lower_file: The lower file
145 * @inode: The ecryptfs inode
146 * @lower_inode: The lower inode
148 * This is the code which will grow the file to its correct size.
150 static int grow_file(struct dentry
*ecryptfs_dentry
, struct file
*lower_file
,
151 struct inode
*inode
, struct inode
*lower_inode
)
154 struct file fake_file
;
155 struct ecryptfs_file_info tmp_file_info
;
157 memset(&fake_file
, 0, sizeof(fake_file
));
158 fake_file
.f_path
.dentry
= ecryptfs_dentry
;
159 memset(&tmp_file_info
, 0, sizeof(tmp_file_info
));
160 ecryptfs_set_file_private(&fake_file
, &tmp_file_info
);
161 ecryptfs_set_file_lower(&fake_file
, lower_file
);
162 rc
= ecryptfs_fill_zeros(&fake_file
, 1);
164 ecryptfs_inode_to_private(inode
)->crypt_stat
.flags
|=
165 ECRYPTFS_SECURITY_WARNING
;
166 ecryptfs_printk(KERN_WARNING
, "Error attempting to fill zeros "
167 "in file; rc = [%d]\n", rc
);
170 i_size_write(inode
, 0);
171 rc
= ecryptfs_write_inode_size_to_metadata(lower_file
, lower_inode
,
172 inode
, ecryptfs_dentry
,
173 ECRYPTFS_LOWER_I_MUTEX_NOT_HELD
);
174 ecryptfs_inode_to_private(inode
)->crypt_stat
.flags
|= ECRYPTFS_NEW_FILE
;
180 * ecryptfs_initialize_file
182 * Cause the file to be changed from a basic empty file to an ecryptfs
183 * file with a header and first data page.
185 * Returns zero on success
187 static int ecryptfs_initialize_file(struct dentry
*ecryptfs_dentry
)
191 struct ecryptfs_crypt_stat
*crypt_stat
;
192 struct dentry
*lower_dentry
;
193 struct file
*lower_file
;
194 struct inode
*inode
, *lower_inode
;
195 struct vfsmount
*lower_mnt
;
197 lower_dentry
= ecryptfs_dentry_to_lower(ecryptfs_dentry
);
198 ecryptfs_printk(KERN_DEBUG
, "lower_dentry->d_name.name = [%s]\n",
199 lower_dentry
->d_name
.name
);
200 inode
= ecryptfs_dentry
->d_inode
;
201 crypt_stat
= &ecryptfs_inode_to_private(inode
)->crypt_stat
;
202 lower_flags
= ((O_CREAT
| O_TRUNC
) & O_ACCMODE
) | O_RDWR
;
203 lower_mnt
= ecryptfs_dentry_to_lower_mnt(ecryptfs_dentry
);
204 /* Corresponding fput() at end of this function */
205 if ((rc
= ecryptfs_open_lower_file(&lower_file
, lower_dentry
, lower_mnt
,
207 ecryptfs_printk(KERN_ERR
,
208 "Error opening dentry; rc = [%i]\n", rc
);
211 lower_inode
= lower_dentry
->d_inode
;
212 if (S_ISDIR(ecryptfs_dentry
->d_inode
->i_mode
)) {
213 ecryptfs_printk(KERN_DEBUG
, "This is a directory\n");
214 crypt_stat
->flags
&= ~(ECRYPTFS_ENCRYPTED
);
217 crypt_stat
->flags
|= ECRYPTFS_NEW_FILE
;
218 ecryptfs_printk(KERN_DEBUG
, "Initializing crypto context\n");
219 rc
= ecryptfs_new_file_context(ecryptfs_dentry
);
221 ecryptfs_printk(KERN_DEBUG
, "Error creating new file "
225 rc
= ecryptfs_write_metadata(ecryptfs_dentry
, lower_file
);
227 ecryptfs_printk(KERN_DEBUG
, "Error writing headers\n");
230 rc
= grow_file(ecryptfs_dentry
, lower_file
, inode
, lower_inode
);
232 if ((rc
= ecryptfs_close_lower_file(lower_file
)))
233 printk(KERN_ERR
"Error closing lower_file\n");
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.
245 * Creates a new file.
247 * Returns zero on success; non-zero on error condition
250 ecryptfs_create(struct inode
*directory_inode
, struct dentry
*ecryptfs_dentry
,
251 int mode
, struct nameidata
*nd
)
255 rc
= ecryptfs_do_create(directory_inode
, ecryptfs_dentry
, mode
, nd
);
257 ecryptfs_printk(KERN_WARNING
, "Failed to create file in"
258 "lower filesystem\n");
261 /* At this point, a file exists on "disk"; we need to make sure
262 * that this on disk file is prepared to be an ecryptfs file */
263 rc
= ecryptfs_initialize_file(ecryptfs_dentry
);
271 * @dentry: The dentry
272 * @nd: nameidata, may be NULL
274 * Find a file on disk. If the file does not exist, then we'll add it to the
275 * dentry cache and continue on to read it from the disk.
277 static struct dentry
*ecryptfs_lookup(struct inode
*dir
, struct dentry
*dentry
,
278 struct nameidata
*nd
)
281 struct dentry
*lower_dir_dentry
;
282 struct dentry
*lower_dentry
;
283 struct vfsmount
*lower_mnt
;
286 struct ecryptfs_crypt_stat
*crypt_stat
= NULL
;
287 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
;
288 char *page_virt
= NULL
;
289 struct inode
*lower_inode
;
292 lower_dir_dentry
= ecryptfs_dentry_to_lower(dentry
->d_parent
);
293 dentry
->d_op
= &ecryptfs_dops
;
294 if ((dentry
->d_name
.len
== 1 && !strcmp(dentry
->d_name
.name
, "."))
295 || (dentry
->d_name
.len
== 2
296 && !strcmp(dentry
->d_name
.name
, ".."))) {
300 encoded_namelen
= ecryptfs_encode_filename(crypt_stat
,
304 if (encoded_namelen
< 0) {
305 rc
= encoded_namelen
;
309 ecryptfs_printk(KERN_DEBUG
, "encoded_name = [%s]; encoded_namelen "
310 "= [%d]\n", encoded_name
, encoded_namelen
);
311 lower_dentry
= lookup_one_len(encoded_name
, lower_dir_dentry
,
312 encoded_namelen
- 1);
314 if (IS_ERR(lower_dentry
)) {
315 ecryptfs_printk(KERN_ERR
, "ERR from lower_dentry\n");
316 rc
= PTR_ERR(lower_dentry
);
320 lower_mnt
= mntget(ecryptfs_dentry_to_lower_mnt(dentry
->d_parent
));
321 ecryptfs_printk(KERN_DEBUG
, "lower_dentry = [%p]; lower_dentry->"
322 "d_name.name = [%s]\n", lower_dentry
,
323 lower_dentry
->d_name
.name
);
324 lower_inode
= lower_dentry
->d_inode
;
325 fsstack_copy_attr_atime(dir
, lower_dir_dentry
->d_inode
);
326 BUG_ON(!atomic_read(&lower_dentry
->d_count
));
327 ecryptfs_set_dentry_private(dentry
,
328 kmem_cache_alloc(ecryptfs_dentry_info_cache
,
330 if (!ecryptfs_dentry_to_private(dentry
)) {
332 ecryptfs_printk(KERN_ERR
, "Out of memory whilst attempting "
333 "to allocate ecryptfs_dentry_info struct\n");
336 ecryptfs_set_dentry_lower(dentry
, lower_dentry
);
337 ecryptfs_set_dentry_lower_mnt(dentry
, lower_mnt
);
338 if (!lower_dentry
->d_inode
) {
339 /* We want to add because we couldn't find in lower */
343 rc
= ecryptfs_interpose(lower_dentry
, dentry
, dir
->i_sb
, 1);
345 ecryptfs_printk(KERN_ERR
, "Error interposing\n");
348 if (S_ISDIR(lower_inode
->i_mode
)) {
349 ecryptfs_printk(KERN_DEBUG
, "Is a directory; returning\n");
352 if (S_ISLNK(lower_inode
->i_mode
)) {
353 ecryptfs_printk(KERN_DEBUG
, "Is a symlink; returning\n");
357 ecryptfs_printk(KERN_DEBUG
, "We have a NULL nd, just leave"
358 "as we *think* we are about to unlink\n");
361 /* Released in this function */
362 page_virt
= kmem_cache_zalloc(ecryptfs_header_cache_2
,
366 ecryptfs_printk(KERN_ERR
,
367 "Cannot ecryptfs_kmalloc a page\n");
370 crypt_stat
= &ecryptfs_inode_to_private(dentry
->d_inode
)->crypt_stat
;
371 if (!(crypt_stat
->flags
& ECRYPTFS_POLICY_APPLIED
))
372 ecryptfs_set_default_sizes(crypt_stat
);
373 rc
= ecryptfs_read_and_validate_header_region(page_virt
, lower_dentry
,
376 rc
= ecryptfs_read_and_validate_xattr_region(page_virt
, dentry
);
378 printk(KERN_DEBUG
"Valid metadata not found in header "
379 "region or xattr region; treating file as "
382 kmem_cache_free(ecryptfs_header_cache_2
, page_virt
);
385 crypt_stat
->flags
|= ECRYPTFS_METADATA_IN_XATTR
;
387 mount_crypt_stat
= &ecryptfs_superblock_to_private(
388 dentry
->d_sb
)->mount_crypt_stat
;
389 if (mount_crypt_stat
->flags
& ECRYPTFS_ENCRYPTED_VIEW_ENABLED
) {
390 if (crypt_stat
->flags
& ECRYPTFS_METADATA_IN_XATTR
)
391 file_size
= (crypt_stat
->header_extent_size
392 + i_size_read(lower_dentry
->d_inode
));
394 file_size
= i_size_read(lower_dentry
->d_inode
);
396 memcpy(&file_size
, page_virt
, sizeof(file_size
));
397 file_size
= be64_to_cpu(file_size
);
399 i_size_write(dentry
->d_inode
, (loff_t
)file_size
);
400 kmem_cache_free(ecryptfs_header_cache_2
, page_virt
);
410 static int ecryptfs_link(struct dentry
*old_dentry
, struct inode
*dir
,
411 struct dentry
*new_dentry
)
413 struct dentry
*lower_old_dentry
;
414 struct dentry
*lower_new_dentry
;
415 struct dentry
*lower_dir_dentry
;
419 file_size_save
= i_size_read(old_dentry
->d_inode
);
420 lower_old_dentry
= ecryptfs_dentry_to_lower(old_dentry
);
421 lower_new_dentry
= ecryptfs_dentry_to_lower(new_dentry
);
422 dget(lower_old_dentry
);
423 dget(lower_new_dentry
);
424 lower_dir_dentry
= lock_parent(lower_new_dentry
);
425 rc
= vfs_link(lower_old_dentry
, lower_dir_dentry
->d_inode
,
427 if (rc
|| !lower_new_dentry
->d_inode
)
429 rc
= ecryptfs_interpose(lower_new_dentry
, new_dentry
, dir
->i_sb
, 0);
432 fsstack_copy_attr_times(dir
, lower_new_dentry
->d_inode
);
433 fsstack_copy_inode_size(dir
, lower_new_dentry
->d_inode
);
434 old_dentry
->d_inode
->i_nlink
=
435 ecryptfs_inode_to_lower(old_dentry
->d_inode
)->i_nlink
;
436 i_size_write(new_dentry
->d_inode
, file_size_save
);
438 unlock_dir(lower_dir_dentry
);
439 dput(lower_new_dentry
);
440 dput(lower_old_dentry
);
441 d_drop(lower_old_dentry
);
447 static int ecryptfs_unlink(struct inode
*dir
, struct dentry
*dentry
)
450 struct dentry
*lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
451 struct inode
*lower_dir_inode
= ecryptfs_inode_to_lower(dir
);
453 lock_parent(lower_dentry
);
454 rc
= vfs_unlink(lower_dir_inode
, lower_dentry
);
456 printk(KERN_ERR
"Error in vfs_unlink; rc = [%d]\n", rc
);
459 fsstack_copy_attr_times(dir
, lower_dir_inode
);
460 dentry
->d_inode
->i_nlink
=
461 ecryptfs_inode_to_lower(dentry
->d_inode
)->i_nlink
;
462 dentry
->d_inode
->i_ctime
= dir
->i_ctime
;
464 unlock_parent(lower_dentry
);
468 static int ecryptfs_symlink(struct inode
*dir
, struct dentry
*dentry
,
472 struct dentry
*lower_dentry
;
473 struct dentry
*lower_dir_dentry
;
475 char *encoded_symname
;
477 struct ecryptfs_crypt_stat
*crypt_stat
= NULL
;
479 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
481 lower_dir_dentry
= lock_parent(lower_dentry
);
483 encoded_symlen
= ecryptfs_encode_filename(crypt_stat
, symname
,
486 if (encoded_symlen
< 0) {
490 rc
= vfs_symlink(lower_dir_dentry
->d_inode
, lower_dentry
,
491 encoded_symname
, mode
);
492 kfree(encoded_symname
);
493 if (rc
|| !lower_dentry
->d_inode
)
495 rc
= ecryptfs_interpose(lower_dentry
, dentry
, dir
->i_sb
, 0);
498 fsstack_copy_attr_times(dir
, lower_dir_dentry
->d_inode
);
499 fsstack_copy_inode_size(dir
, lower_dir_dentry
->d_inode
);
501 unlock_dir(lower_dir_dentry
);
503 if (!dentry
->d_inode
)
508 static int ecryptfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
511 struct dentry
*lower_dentry
;
512 struct dentry
*lower_dir_dentry
;
514 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
515 lower_dir_dentry
= lock_parent(lower_dentry
);
516 rc
= vfs_mkdir(lower_dir_dentry
->d_inode
, lower_dentry
, mode
);
517 if (rc
|| !lower_dentry
->d_inode
)
519 rc
= ecryptfs_interpose(lower_dentry
, dentry
, dir
->i_sb
, 0);
522 fsstack_copy_attr_times(dir
, lower_dir_dentry
->d_inode
);
523 fsstack_copy_inode_size(dir
, lower_dir_dentry
->d_inode
);
524 dir
->i_nlink
= lower_dir_dentry
->d_inode
->i_nlink
;
526 unlock_dir(lower_dir_dentry
);
527 if (!dentry
->d_inode
)
532 static int ecryptfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
534 struct dentry
*lower_dentry
;
535 struct dentry
*lower_dir_dentry
;
538 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
540 lower_dir_dentry
= lock_parent(lower_dentry
);
542 rc
= vfs_rmdir(lower_dir_dentry
->d_inode
, lower_dentry
);
545 d_delete(lower_dentry
);
546 fsstack_copy_attr_times(dir
, lower_dir_dentry
->d_inode
);
547 dir
->i_nlink
= lower_dir_dentry
->d_inode
->i_nlink
;
548 unlock_dir(lower_dir_dentry
);
556 ecryptfs_mknod(struct inode
*dir
, struct dentry
*dentry
, int mode
, dev_t dev
)
559 struct dentry
*lower_dentry
;
560 struct dentry
*lower_dir_dentry
;
562 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
563 lower_dir_dentry
= lock_parent(lower_dentry
);
564 rc
= vfs_mknod(lower_dir_dentry
->d_inode
, lower_dentry
, mode
, dev
);
565 if (rc
|| !lower_dentry
->d_inode
)
567 rc
= ecryptfs_interpose(lower_dentry
, dentry
, dir
->i_sb
, 0);
570 fsstack_copy_attr_times(dir
, lower_dir_dentry
->d_inode
);
571 fsstack_copy_inode_size(dir
, lower_dir_dentry
->d_inode
);
573 unlock_dir(lower_dir_dentry
);
574 if (!dentry
->d_inode
)
580 ecryptfs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
581 struct inode
*new_dir
, struct dentry
*new_dentry
)
584 struct dentry
*lower_old_dentry
;
585 struct dentry
*lower_new_dentry
;
586 struct dentry
*lower_old_dir_dentry
;
587 struct dentry
*lower_new_dir_dentry
;
589 lower_old_dentry
= ecryptfs_dentry_to_lower(old_dentry
);
590 lower_new_dentry
= ecryptfs_dentry_to_lower(new_dentry
);
591 dget(lower_old_dentry
);
592 dget(lower_new_dentry
);
593 lower_old_dir_dentry
= dget_parent(lower_old_dentry
);
594 lower_new_dir_dentry
= dget_parent(lower_new_dentry
);
595 lock_rename(lower_old_dir_dentry
, lower_new_dir_dentry
);
596 rc
= vfs_rename(lower_old_dir_dentry
->d_inode
, lower_old_dentry
,
597 lower_new_dir_dentry
->d_inode
, lower_new_dentry
);
600 fsstack_copy_attr_all(new_dir
, lower_new_dir_dentry
->d_inode
, NULL
);
601 if (new_dir
!= old_dir
)
602 fsstack_copy_attr_all(old_dir
, lower_old_dir_dentry
->d_inode
, NULL
);
604 unlock_rename(lower_old_dir_dentry
, lower_new_dir_dentry
);
605 dput(lower_new_dentry
->d_parent
);
606 dput(lower_old_dentry
->d_parent
);
607 dput(lower_new_dentry
);
608 dput(lower_old_dentry
);
613 ecryptfs_readlink(struct dentry
*dentry
, char __user
* buf
, int bufsiz
)
616 struct dentry
*lower_dentry
;
620 struct ecryptfs_crypt_stat
*crypt_stat
;
622 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
623 if (!lower_dentry
->d_inode
->i_op
||
624 !lower_dentry
->d_inode
->i_op
->readlink
) {
628 /* Released in this function */
629 lower_buf
= kmalloc(bufsiz
, GFP_KERNEL
);
630 if (lower_buf
== NULL
) {
631 ecryptfs_printk(KERN_ERR
, "Out of memory\n");
637 ecryptfs_printk(KERN_DEBUG
, "Calling readlink w/ "
638 "lower_dentry->d_name.name = [%s]\n",
639 lower_dentry
->d_name
.name
);
640 rc
= lower_dentry
->d_inode
->i_op
->readlink(lower_dentry
,
641 (char __user
*)lower_buf
,
646 rc
= ecryptfs_decode_filename(crypt_stat
, lower_buf
, rc
,
649 goto out_free_lower_buf
;
651 ecryptfs_printk(KERN_DEBUG
, "Copying [%d] bytes "
652 "to userspace: [%*s]\n", rc
,
654 if (copy_to_user(buf
, decoded_name
, rc
))
658 fsstack_copy_attr_atime(dentry
->d_inode
,
659 lower_dentry
->d_inode
);
667 static void *ecryptfs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
670 int len
= PAGE_SIZE
, rc
;
673 /* Released in ecryptfs_put_link(); only release here on error */
674 buf
= kmalloc(len
, GFP_KERNEL
);
681 ecryptfs_printk(KERN_DEBUG
, "Calling readlink w/ "
682 "dentry->d_name.name = [%s]\n", dentry
->d_name
.name
);
683 rc
= dentry
->d_inode
->i_op
->readlink(dentry
, (char __user
*)buf
, len
);
689 nd_set_link(nd
, buf
);
698 ecryptfs_put_link(struct dentry
*dentry
, struct nameidata
*nd
, void *ptr
)
701 kfree(nd_get_link(nd
));
705 * upper_size_to_lower_size
706 * @crypt_stat: Crypt_stat associated with file
707 * @upper_size: Size of the upper file
709 * Calculate the requried size of the lower file based on the
710 * specified size of the upper file. This calculation is based on the
711 * number of headers in the underlying file and the extent size.
713 * Returns Calculated size of the lower file.
716 upper_size_to_lower_size(struct ecryptfs_crypt_stat
*crypt_stat
,
721 lower_size
= ( crypt_stat
->header_extent_size
722 * crypt_stat
->num_header_extents_at_front
);
723 if (upper_size
!= 0) {
726 num_extents
= upper_size
>> crypt_stat
->extent_shift
;
727 if (upper_size
& ~crypt_stat
->extent_mask
)
729 lower_size
+= (num_extents
* crypt_stat
->extent_size
);
736 * @dentry: The ecryptfs layer dentry
737 * @new_length: The length to expand the file to
739 * Function to handle truncations modifying the size of the file. Note
740 * that the file sizes are interpolated. When expanding, we are simply
741 * writing strings of 0's out. When truncating, we need to modify the
742 * underlying file size according to the page index interpolations.
744 * Returns zero on success; non-zero otherwise
746 int ecryptfs_truncate(struct dentry
*dentry
, loff_t new_length
)
749 struct inode
*inode
= dentry
->d_inode
;
750 struct dentry
*lower_dentry
;
751 struct vfsmount
*lower_mnt
;
752 struct file fake_ecryptfs_file
, *lower_file
= NULL
;
753 struct ecryptfs_crypt_stat
*crypt_stat
;
754 loff_t i_size
= i_size_read(inode
);
755 loff_t lower_size_before_truncate
;
756 loff_t lower_size_after_truncate
;
758 if (unlikely((new_length
== i_size
)))
760 crypt_stat
= &ecryptfs_inode_to_private(dentry
->d_inode
)->crypt_stat
;
761 /* Set up a fake ecryptfs file, this is used to interface with
762 * the file in the underlying filesystem so that the
763 * truncation has an effect there as well. */
764 memset(&fake_ecryptfs_file
, 0, sizeof(fake_ecryptfs_file
));
765 fake_ecryptfs_file
.f_path
.dentry
= dentry
;
766 /* Released at out_free: label */
767 ecryptfs_set_file_private(&fake_ecryptfs_file
,
768 kmem_cache_alloc(ecryptfs_file_info_cache
,
770 if (unlikely(!ecryptfs_file_to_private(&fake_ecryptfs_file
))) {
774 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
775 /* This dget & mntget is released through fput at out_fput: */
776 lower_mnt
= ecryptfs_dentry_to_lower_mnt(dentry
);
777 if ((rc
= ecryptfs_open_lower_file(&lower_file
, lower_dentry
, lower_mnt
,
779 ecryptfs_printk(KERN_ERR
,
780 "Error opening dentry; rc = [%i]\n", rc
);
783 ecryptfs_set_file_lower(&fake_ecryptfs_file
, lower_file
);
784 /* Switch on growing or shrinking file */
785 if (new_length
> i_size
) {
786 rc
= ecryptfs_fill_zeros(&fake_ecryptfs_file
, new_length
);
788 ecryptfs_printk(KERN_ERR
,
789 "Problem with fill_zeros\n");
792 i_size_write(inode
, new_length
);
793 rc
= ecryptfs_write_inode_size_to_metadata(
794 lower_file
, lower_dentry
->d_inode
, inode
, dentry
,
795 ECRYPTFS_LOWER_I_MUTEX_NOT_HELD
);
797 printk(KERN_ERR
"Problem with "
798 "ecryptfs_write_inode_size_to_metadata; "
802 } else { /* new_length < i_size_read(inode) */
804 int end_pos_in_page
= -1;
806 if (new_length
!= 0) {
807 index
= ((new_length
- 1) >> PAGE_CACHE_SHIFT
);
808 end_pos_in_page
= ((new_length
- 1) & ~PAGE_CACHE_MASK
);
810 if (end_pos_in_page
!= (PAGE_CACHE_SIZE
- 1)) {
811 if ((rc
= ecryptfs_write_zeros(&fake_ecryptfs_file
,
813 (end_pos_in_page
+ 1),
814 ((PAGE_CACHE_SIZE
- 1)
815 - end_pos_in_page
)))) {
816 printk(KERN_ERR
"Error attempting to zero out "
817 "the remainder of the end page on "
818 "reducing truncate; rc = [%d]\n", rc
);
822 vmtruncate(inode
, new_length
);
823 rc
= ecryptfs_write_inode_size_to_metadata(
824 lower_file
, lower_dentry
->d_inode
, inode
, dentry
,
825 ECRYPTFS_LOWER_I_MUTEX_NOT_HELD
);
827 printk(KERN_ERR
"Problem with "
828 "ecryptfs_write_inode_size_to_metadata; "
832 /* We are reducing the size of the ecryptfs file, and need to
833 * know if we need to reduce the size of the lower file. */
834 lower_size_before_truncate
=
835 upper_size_to_lower_size(crypt_stat
, i_size
);
836 lower_size_after_truncate
=
837 upper_size_to_lower_size(crypt_stat
, new_length
);
838 if (lower_size_after_truncate
< lower_size_before_truncate
)
839 vmtruncate(lower_dentry
->d_inode
,
840 lower_size_after_truncate
);
842 /* Update the access times */
843 lower_dentry
->d_inode
->i_mtime
= lower_dentry
->d_inode
->i_ctime
845 mark_inode_dirty_sync(inode
);
847 if ((rc
= ecryptfs_close_lower_file(lower_file
)))
848 printk(KERN_ERR
"Error closing lower_file\n");
850 if (ecryptfs_file_to_private(&fake_ecryptfs_file
))
851 kmem_cache_free(ecryptfs_file_info_cache
,
852 ecryptfs_file_to_private(&fake_ecryptfs_file
));
858 ecryptfs_permission(struct inode
*inode
, int mask
, struct nameidata
*nd
)
863 struct vfsmount
*vfsmnt_save
= nd
->mnt
;
864 struct dentry
*dentry_save
= nd
->dentry
;
866 nd
->mnt
= ecryptfs_dentry_to_lower_mnt(nd
->dentry
);
867 nd
->dentry
= ecryptfs_dentry_to_lower(nd
->dentry
);
868 rc
= permission(ecryptfs_inode_to_lower(inode
), mask
, nd
);
869 nd
->mnt
= vfsmnt_save
;
870 nd
->dentry
= dentry_save
;
872 rc
= permission(ecryptfs_inode_to_lower(inode
), mask
, NULL
);
878 * @dentry: dentry handle to the inode to modify
879 * @ia: Structure with flags of what to change and values
881 * Updates the metadata of an inode. If the update is to the size
882 * i.e. truncation, then ecryptfs_truncate will handle the size modification
883 * of both the ecryptfs inode and the lower inode.
885 * All other metadata changes will be passed right to the lower filesystem,
886 * and we will just update our inode to look like the lower.
888 static int ecryptfs_setattr(struct dentry
*dentry
, struct iattr
*ia
)
891 struct dentry
*lower_dentry
;
893 struct inode
*lower_inode
;
894 struct ecryptfs_crypt_stat
*crypt_stat
;
896 crypt_stat
= &ecryptfs_inode_to_private(dentry
->d_inode
)->crypt_stat
;
897 if (!(crypt_stat
->flags
& ECRYPTFS_STRUCT_INITIALIZED
))
898 ecryptfs_init_crypt_stat(crypt_stat
);
899 inode
= dentry
->d_inode
;
900 lower_inode
= ecryptfs_inode_to_lower(inode
);
901 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
902 mutex_lock(&crypt_stat
->cs_mutex
);
903 if (S_ISDIR(dentry
->d_inode
->i_mode
))
904 crypt_stat
->flags
&= ~(ECRYPTFS_ENCRYPTED
);
905 else if (S_ISREG(dentry
->d_inode
->i_mode
)
906 && (!(crypt_stat
->flags
& ECRYPTFS_POLICY_APPLIED
)
907 || !(crypt_stat
->flags
& ECRYPTFS_KEY_VALID
))) {
908 struct vfsmount
*lower_mnt
;
909 struct file
*lower_file
= NULL
;
910 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
;
913 lower_mnt
= ecryptfs_dentry_to_lower_mnt(dentry
);
914 lower_flags
= O_RDONLY
;
915 if ((rc
= ecryptfs_open_lower_file(&lower_file
, lower_dentry
,
916 lower_mnt
, lower_flags
))) {
918 "Error opening lower file; rc = [%d]\n", rc
);
919 mutex_unlock(&crypt_stat
->cs_mutex
);
922 mount_crypt_stat
= &ecryptfs_superblock_to_private(
923 dentry
->d_sb
)->mount_crypt_stat
;
924 if ((rc
= ecryptfs_read_metadata(dentry
, lower_file
))) {
925 if (!(mount_crypt_stat
->flags
926 & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED
)) {
928 printk(KERN_WARNING
"Attempt to read file that "
929 "is not in a valid eCryptfs format, "
930 "and plaintext passthrough mode is not "
931 "enabled; returning -EIO\n");
933 mutex_unlock(&crypt_stat
->cs_mutex
);
938 crypt_stat
->flags
&= ~(ECRYPTFS_ENCRYPTED
);
939 mutex_unlock(&crypt_stat
->cs_mutex
);
945 mutex_unlock(&crypt_stat
->cs_mutex
);
946 if (ia
->ia_valid
& ATTR_SIZE
) {
947 ecryptfs_printk(KERN_DEBUG
,
948 "ia->ia_valid = [0x%x] ATTR_SIZE" " = [0x%x]\n",
949 ia
->ia_valid
, ATTR_SIZE
);
950 rc
= ecryptfs_truncate(dentry
, ia
->ia_size
);
951 /* ecryptfs_truncate handles resizing of the lower file */
952 ia
->ia_valid
&= ~ATTR_SIZE
;
953 ecryptfs_printk(KERN_DEBUG
, "ia->ia_valid = [%x]\n",
958 rc
= notify_change(lower_dentry
, ia
);
960 fsstack_copy_attr_all(inode
, lower_inode
, NULL
);
965 ecryptfs_setxattr(struct dentry
*dentry
, const char *name
, const void *value
,
966 size_t size
, int flags
)
969 struct dentry
*lower_dentry
;
971 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
972 if (!lower_dentry
->d_inode
->i_op
->setxattr
) {
976 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
977 rc
= lower_dentry
->d_inode
->i_op
->setxattr(lower_dentry
, name
, value
,
979 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
985 ecryptfs_getxattr(struct dentry
*dentry
, const char *name
, void *value
,
989 struct dentry
*lower_dentry
;
991 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
992 if (!lower_dentry
->d_inode
->i_op
->getxattr
) {
996 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
997 rc
= lower_dentry
->d_inode
->i_op
->getxattr(lower_dentry
, name
, value
,
999 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
1005 ecryptfs_listxattr(struct dentry
*dentry
, char *list
, size_t size
)
1008 struct dentry
*lower_dentry
;
1010 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
1011 if (!lower_dentry
->d_inode
->i_op
->listxattr
) {
1015 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
1016 rc
= lower_dentry
->d_inode
->i_op
->listxattr(lower_dentry
, list
, size
);
1017 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
1022 static int ecryptfs_removexattr(struct dentry
*dentry
, const char *name
)
1025 struct dentry
*lower_dentry
;
1027 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
1028 if (!lower_dentry
->d_inode
->i_op
->removexattr
) {
1032 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
1033 rc
= lower_dentry
->d_inode
->i_op
->removexattr(lower_dentry
, name
);
1034 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
1039 int ecryptfs_inode_test(struct inode
*inode
, void *candidate_lower_inode
)
1041 if ((ecryptfs_inode_to_lower(inode
)
1042 == (struct inode
*)candidate_lower_inode
))
1048 int ecryptfs_inode_set(struct inode
*inode
, void *lower_inode
)
1050 ecryptfs_init_inode(inode
, (struct inode
*)lower_inode
);
1054 const struct inode_operations ecryptfs_symlink_iops
= {
1055 .readlink
= ecryptfs_readlink
,
1056 .follow_link
= ecryptfs_follow_link
,
1057 .put_link
= ecryptfs_put_link
,
1058 .permission
= ecryptfs_permission
,
1059 .setattr
= ecryptfs_setattr
,
1060 .setxattr
= ecryptfs_setxattr
,
1061 .getxattr
= ecryptfs_getxattr
,
1062 .listxattr
= ecryptfs_listxattr
,
1063 .removexattr
= ecryptfs_removexattr
1066 const struct inode_operations ecryptfs_dir_iops
= {
1067 .create
= ecryptfs_create
,
1068 .lookup
= ecryptfs_lookup
,
1069 .link
= ecryptfs_link
,
1070 .unlink
= ecryptfs_unlink
,
1071 .symlink
= ecryptfs_symlink
,
1072 .mkdir
= ecryptfs_mkdir
,
1073 .rmdir
= ecryptfs_rmdir
,
1074 .mknod
= ecryptfs_mknod
,
1075 .rename
= ecryptfs_rename
,
1076 .permission
= ecryptfs_permission
,
1077 .setattr
= ecryptfs_setattr
,
1078 .setxattr
= ecryptfs_setxattr
,
1079 .getxattr
= ecryptfs_getxattr
,
1080 .listxattr
= ecryptfs_listxattr
,
1081 .removexattr
= ecryptfs_removexattr
1084 const struct inode_operations ecryptfs_main_iops
= {
1085 .permission
= ecryptfs_permission
,
1086 .setattr
= ecryptfs_setattr
,
1087 .setxattr
= ecryptfs_setxattr
,
1088 .getxattr
= ecryptfs_getxattr
,
1089 .listxattr
= ecryptfs_listxattr
,
1090 .removexattr
= ecryptfs_removexattr