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
;
285 unsigned int encoded_namelen
;
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
;
476 unsigned int encoded_symlen
;
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) */
803 vmtruncate(inode
, new_length
);
804 rc
= ecryptfs_write_inode_size_to_metadata(
805 lower_file
, lower_dentry
->d_inode
, inode
, dentry
,
806 ECRYPTFS_LOWER_I_MUTEX_NOT_HELD
);
808 printk(KERN_ERR
"Problem with "
809 "ecryptfs_write_inode_size_to_metadata; "
813 /* We are reducing the size of the ecryptfs file, and need to
814 * know if we need to reduce the size of the lower file. */
815 lower_size_before_truncate
=
816 upper_size_to_lower_size(crypt_stat
, i_size
);
817 lower_size_after_truncate
=
818 upper_size_to_lower_size(crypt_stat
, new_length
);
819 if (lower_size_after_truncate
< lower_size_before_truncate
)
820 vmtruncate(lower_dentry
->d_inode
,
821 lower_size_after_truncate
);
823 /* Update the access times */
824 lower_dentry
->d_inode
->i_mtime
= lower_dentry
->d_inode
->i_ctime
826 mark_inode_dirty_sync(inode
);
828 if ((rc
= ecryptfs_close_lower_file(lower_file
)))
829 printk(KERN_ERR
"Error closing lower_file\n");
831 if (ecryptfs_file_to_private(&fake_ecryptfs_file
))
832 kmem_cache_free(ecryptfs_file_info_cache
,
833 ecryptfs_file_to_private(&fake_ecryptfs_file
));
839 ecryptfs_permission(struct inode
*inode
, int mask
, struct nameidata
*nd
)
844 struct vfsmount
*vfsmnt_save
= nd
->mnt
;
845 struct dentry
*dentry_save
= nd
->dentry
;
847 nd
->mnt
= ecryptfs_dentry_to_lower_mnt(nd
->dentry
);
848 nd
->dentry
= ecryptfs_dentry_to_lower(nd
->dentry
);
849 rc
= permission(ecryptfs_inode_to_lower(inode
), mask
, nd
);
850 nd
->mnt
= vfsmnt_save
;
851 nd
->dentry
= dentry_save
;
853 rc
= permission(ecryptfs_inode_to_lower(inode
), mask
, NULL
);
859 * @dentry: dentry handle to the inode to modify
860 * @ia: Structure with flags of what to change and values
862 * Updates the metadata of an inode. If the update is to the size
863 * i.e. truncation, then ecryptfs_truncate will handle the size modification
864 * of both the ecryptfs inode and the lower inode.
866 * All other metadata changes will be passed right to the lower filesystem,
867 * and we will just update our inode to look like the lower.
869 static int ecryptfs_setattr(struct dentry
*dentry
, struct iattr
*ia
)
872 struct dentry
*lower_dentry
;
874 struct inode
*lower_inode
;
875 struct ecryptfs_crypt_stat
*crypt_stat
;
877 crypt_stat
= &ecryptfs_inode_to_private(dentry
->d_inode
)->crypt_stat
;
878 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
879 inode
= dentry
->d_inode
;
880 lower_inode
= ecryptfs_inode_to_lower(inode
);
881 if (ia
->ia_valid
& ATTR_SIZE
) {
882 ecryptfs_printk(KERN_DEBUG
,
883 "ia->ia_valid = [0x%x] ATTR_SIZE" " = [0x%x]\n",
884 ia
->ia_valid
, ATTR_SIZE
);
885 rc
= ecryptfs_truncate(dentry
, ia
->ia_size
);
886 /* ecryptfs_truncate handles resizing of the lower file */
887 ia
->ia_valid
&= ~ATTR_SIZE
;
888 ecryptfs_printk(KERN_DEBUG
, "ia->ia_valid = [%x]\n",
893 rc
= notify_change(lower_dentry
, ia
);
895 fsstack_copy_attr_all(inode
, lower_inode
, NULL
);
900 ecryptfs_setxattr(struct dentry
*dentry
, const char *name
, const void *value
,
901 size_t size
, int flags
)
904 struct dentry
*lower_dentry
;
906 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
907 if (!lower_dentry
->d_inode
->i_op
->setxattr
) {
911 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
912 rc
= lower_dentry
->d_inode
->i_op
->setxattr(lower_dentry
, name
, value
,
914 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
920 ecryptfs_getxattr(struct dentry
*dentry
, const char *name
, void *value
,
924 struct dentry
*lower_dentry
;
926 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
927 if (!lower_dentry
->d_inode
->i_op
->getxattr
) {
931 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
932 rc
= lower_dentry
->d_inode
->i_op
->getxattr(lower_dentry
, name
, value
,
934 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
940 ecryptfs_listxattr(struct dentry
*dentry
, char *list
, size_t size
)
943 struct dentry
*lower_dentry
;
945 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
946 if (!lower_dentry
->d_inode
->i_op
->listxattr
) {
950 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
951 rc
= lower_dentry
->d_inode
->i_op
->listxattr(lower_dentry
, list
, size
);
952 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
957 static int ecryptfs_removexattr(struct dentry
*dentry
, const char *name
)
960 struct dentry
*lower_dentry
;
962 lower_dentry
= ecryptfs_dentry_to_lower(dentry
);
963 if (!lower_dentry
->d_inode
->i_op
->removexattr
) {
967 mutex_lock(&lower_dentry
->d_inode
->i_mutex
);
968 rc
= lower_dentry
->d_inode
->i_op
->removexattr(lower_dentry
, name
);
969 mutex_unlock(&lower_dentry
->d_inode
->i_mutex
);
974 int ecryptfs_inode_test(struct inode
*inode
, void *candidate_lower_inode
)
976 if ((ecryptfs_inode_to_lower(inode
)
977 == (struct inode
*)candidate_lower_inode
))
983 int ecryptfs_inode_set(struct inode
*inode
, void *lower_inode
)
985 ecryptfs_init_inode(inode
, (struct inode
*)lower_inode
);
989 const struct inode_operations ecryptfs_symlink_iops
= {
990 .readlink
= ecryptfs_readlink
,
991 .follow_link
= ecryptfs_follow_link
,
992 .put_link
= ecryptfs_put_link
,
993 .permission
= ecryptfs_permission
,
994 .setattr
= ecryptfs_setattr
,
995 .setxattr
= ecryptfs_setxattr
,
996 .getxattr
= ecryptfs_getxattr
,
997 .listxattr
= ecryptfs_listxattr
,
998 .removexattr
= ecryptfs_removexattr
1001 const struct inode_operations ecryptfs_dir_iops
= {
1002 .create
= ecryptfs_create
,
1003 .lookup
= ecryptfs_lookup
,
1004 .link
= ecryptfs_link
,
1005 .unlink
= ecryptfs_unlink
,
1006 .symlink
= ecryptfs_symlink
,
1007 .mkdir
= ecryptfs_mkdir
,
1008 .rmdir
= ecryptfs_rmdir
,
1009 .mknod
= ecryptfs_mknod
,
1010 .rename
= ecryptfs_rename
,
1011 .permission
= ecryptfs_permission
,
1012 .setattr
= ecryptfs_setattr
,
1013 .setxattr
= ecryptfs_setxattr
,
1014 .getxattr
= ecryptfs_getxattr
,
1015 .listxattr
= ecryptfs_listxattr
,
1016 .removexattr
= ecryptfs_removexattr
1019 const struct inode_operations ecryptfs_main_iops
= {
1020 .permission
= ecryptfs_permission
,
1021 .setattr
= ecryptfs_setattr
,
1022 .setxattr
= ecryptfs_setxattr
,
1023 .getxattr
= ecryptfs_getxattr
,
1024 .listxattr
= ecryptfs_listxattr
,
1025 .removexattr
= ecryptfs_removexattr