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 <mhalcrow@us.ibm.com>
8 * Michael C. Thompson <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/poll.h>
28 #include <linux/slab.h>
29 #include <linux/mount.h>
30 #include <linux/pagemap.h>
31 #include <linux/security.h>
32 #include <linux/compat.h>
33 #include <linux/fs_stack.h>
34 #include "ecryptfs_kernel.h"
37 * ecryptfs_read_update_atime
39 * generic_file_read updates the atime of upper layer inode. But, it
40 * doesn't give us a chance to update the atime of the lower layer
41 * inode. This function is a wrapper to generic_file_read. It
42 * updates the atime of the lower level inode if generic_file_read
43 * returns without any errors. This is to be used only for file reads.
44 * The function to be used for directory reads is ecryptfs_read.
46 static ssize_t
ecryptfs_read_update_atime(struct kiocb
*iocb
,
47 const struct iovec
*iov
,
48 unsigned long nr_segs
, loff_t pos
)
52 struct file
*file
= iocb
->ki_filp
;
54 rc
= generic_file_aio_read(iocb
, iov
, nr_segs
, pos
);
56 * Even though this is a async interface, we need to wait
57 * for IO to finish to update atime
59 if (-EIOCBQUEUED
== rc
)
60 rc
= wait_on_sync_kiocb(iocb
);
62 lower
.dentry
= ecryptfs_dentry_to_lower(file
->f_path
.dentry
);
63 lower
.mnt
= ecryptfs_dentry_to_lower_mnt(file
->f_path
.dentry
);
69 struct ecryptfs_getdents_callback
{
71 struct dentry
*dentry
;
77 /* Inspired by generic filldir in fs/readdir.c */
79 ecryptfs_filldir(void *dirent
, const char *lower_name
, int lower_namelen
,
80 loff_t offset
, u64 ino
, unsigned int d_type
)
82 struct ecryptfs_getdents_callback
*buf
=
83 (struct ecryptfs_getdents_callback
*)dirent
;
88 buf
->filldir_called
++;
89 rc
= ecryptfs_decode_and_decrypt_filename(&name
, &name_size
,
90 buf
->dentry
, lower_name
,
93 printk(KERN_ERR
"%s: Error attempting to decode and decrypt "
94 "filename [%s]; rc = [%d]\n", __func__
, lower_name
,
98 rc
= buf
->filldir(buf
->dirent
, name
, name_size
, offset
, ino
, d_type
);
101 buf
->entries_written
++;
108 * @file: The eCryptfs directory file
109 * @dirent: Directory entry handle
110 * @filldir: The filldir callback function
112 static int ecryptfs_readdir(struct file
*file
, void *dirent
, filldir_t filldir
)
115 struct file
*lower_file
;
117 struct ecryptfs_getdents_callback buf
;
119 lower_file
= ecryptfs_file_to_lower(file
);
120 lower_file
->f_pos
= file
->f_pos
;
121 inode
= file_inode(file
);
122 memset(&buf
, 0, sizeof(buf
));
124 buf
.dentry
= file
->f_path
.dentry
;
125 buf
.filldir
= filldir
;
126 buf
.filldir_called
= 0;
127 buf
.entries_written
= 0;
128 rc
= vfs_readdir(lower_file
, ecryptfs_filldir
, (void *)&buf
);
129 file
->f_pos
= lower_file
->f_pos
;
132 if (buf
.filldir_called
&& !buf
.entries_written
)
135 fsstack_copy_attr_atime(inode
,
136 file_inode(lower_file
));
141 struct kmem_cache
*ecryptfs_file_info_cache
;
143 static int read_or_initialize_metadata(struct dentry
*dentry
)
145 struct inode
*inode
= dentry
->d_inode
;
146 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
;
147 struct ecryptfs_crypt_stat
*crypt_stat
;
150 crypt_stat
= &ecryptfs_inode_to_private(inode
)->crypt_stat
;
151 mount_crypt_stat
= &ecryptfs_superblock_to_private(
152 inode
->i_sb
)->mount_crypt_stat
;
153 mutex_lock(&crypt_stat
->cs_mutex
);
155 if (crypt_stat
->flags
& ECRYPTFS_POLICY_APPLIED
&&
156 crypt_stat
->flags
& ECRYPTFS_KEY_VALID
) {
161 rc
= ecryptfs_read_metadata(dentry
);
165 if (mount_crypt_stat
->flags
& ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED
) {
166 crypt_stat
->flags
&= ~(ECRYPTFS_I_SIZE_INITIALIZED
167 | ECRYPTFS_ENCRYPTED
);
172 if (!(mount_crypt_stat
->flags
& ECRYPTFS_XATTR_METADATA_ENABLED
) &&
173 !i_size_read(ecryptfs_inode_to_lower(inode
))) {
174 rc
= ecryptfs_initialize_file(dentry
, inode
);
181 mutex_unlock(&crypt_stat
->cs_mutex
);
187 * @inode: inode speciying file to open
188 * @file: Structure to return filled in
190 * Opens the file specified by inode.
192 * Returns zero on success; non-zero otherwise
194 static int ecryptfs_open(struct inode
*inode
, struct file
*file
)
197 struct ecryptfs_crypt_stat
*crypt_stat
= NULL
;
198 struct ecryptfs_mount_crypt_stat
*mount_crypt_stat
;
199 struct dentry
*ecryptfs_dentry
= file
->f_path
.dentry
;
200 /* Private value of ecryptfs_dentry allocated in
201 * ecryptfs_lookup() */
202 struct ecryptfs_file_info
*file_info
;
204 mount_crypt_stat
= &ecryptfs_superblock_to_private(
205 ecryptfs_dentry
->d_sb
)->mount_crypt_stat
;
206 if ((mount_crypt_stat
->flags
& ECRYPTFS_ENCRYPTED_VIEW_ENABLED
)
207 && ((file
->f_flags
& O_WRONLY
) || (file
->f_flags
& O_RDWR
)
208 || (file
->f_flags
& O_CREAT
) || (file
->f_flags
& O_TRUNC
)
209 || (file
->f_flags
& O_APPEND
))) {
210 printk(KERN_WARNING
"Mount has encrypted view enabled; "
211 "files may only be read\n");
215 /* Released in ecryptfs_release or end of function if failure */
216 file_info
= kmem_cache_zalloc(ecryptfs_file_info_cache
, GFP_KERNEL
);
217 ecryptfs_set_file_private(file
, file_info
);
219 ecryptfs_printk(KERN_ERR
,
220 "Error attempting to allocate memory\n");
224 crypt_stat
= &ecryptfs_inode_to_private(inode
)->crypt_stat
;
225 mutex_lock(&crypt_stat
->cs_mutex
);
226 if (!(crypt_stat
->flags
& ECRYPTFS_POLICY_APPLIED
)) {
227 ecryptfs_printk(KERN_DEBUG
, "Setting flags for stat...\n");
228 /* Policy code enabled in future release */
229 crypt_stat
->flags
|= (ECRYPTFS_POLICY_APPLIED
230 | ECRYPTFS_ENCRYPTED
);
232 mutex_unlock(&crypt_stat
->cs_mutex
);
233 rc
= ecryptfs_get_lower_file(ecryptfs_dentry
, inode
);
235 printk(KERN_ERR
"%s: Error attempting to initialize "
236 "the lower file for the dentry with name "
237 "[%s]; rc = [%d]\n", __func__
,
238 ecryptfs_dentry
->d_name
.name
, rc
);
241 if ((ecryptfs_inode_to_private(inode
)->lower_file
->f_flags
& O_ACCMODE
)
242 == O_RDONLY
&& (file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
244 printk(KERN_WARNING
"%s: Lower file is RO; eCryptfs "
245 "file must hence be opened RO\n", __func__
);
248 ecryptfs_set_file_lower(
249 file
, ecryptfs_inode_to_private(inode
)->lower_file
);
250 if (S_ISDIR(ecryptfs_dentry
->d_inode
->i_mode
)) {
251 ecryptfs_printk(KERN_DEBUG
, "This is a directory\n");
252 mutex_lock(&crypt_stat
->cs_mutex
);
253 crypt_stat
->flags
&= ~(ECRYPTFS_ENCRYPTED
);
254 mutex_unlock(&crypt_stat
->cs_mutex
);
258 rc
= read_or_initialize_metadata(ecryptfs_dentry
);
261 ecryptfs_printk(KERN_DEBUG
, "inode w/ addr = [0x%p], i_ino = "
262 "[0x%.16lx] size: [0x%.16llx]\n", inode
, inode
->i_ino
,
263 (unsigned long long)i_size_read(inode
));
266 ecryptfs_put_lower_file(inode
);
268 kmem_cache_free(ecryptfs_file_info_cache
,
269 ecryptfs_file_to_private(file
));
274 static int ecryptfs_flush(struct file
*file
, fl_owner_t td
)
276 struct file
*lower_file
= ecryptfs_file_to_lower(file
);
278 if (lower_file
->f_op
&& lower_file
->f_op
->flush
) {
279 filemap_write_and_wait(file
->f_mapping
);
280 return lower_file
->f_op
->flush(lower_file
, td
);
286 static int ecryptfs_release(struct inode
*inode
, struct file
*file
)
288 ecryptfs_put_lower_file(inode
);
289 kmem_cache_free(ecryptfs_file_info_cache
,
290 ecryptfs_file_to_private(file
));
295 ecryptfs_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
297 return vfs_fsync(ecryptfs_file_to_lower(file
), datasync
);
300 static int ecryptfs_fasync(int fd
, struct file
*file
, int flag
)
303 struct file
*lower_file
= NULL
;
305 lower_file
= ecryptfs_file_to_lower(file
);
306 if (lower_file
->f_op
&& lower_file
->f_op
->fasync
)
307 rc
= lower_file
->f_op
->fasync(fd
, lower_file
, flag
);
312 ecryptfs_unlocked_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
314 struct file
*lower_file
= NULL
;
317 if (ecryptfs_file_to_private(file
))
318 lower_file
= ecryptfs_file_to_lower(file
);
319 if (lower_file
&& lower_file
->f_op
&& lower_file
->f_op
->unlocked_ioctl
)
320 rc
= lower_file
->f_op
->unlocked_ioctl(lower_file
, cmd
, arg
);
326 ecryptfs_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
328 struct file
*lower_file
= NULL
;
329 long rc
= -ENOIOCTLCMD
;
331 if (ecryptfs_file_to_private(file
))
332 lower_file
= ecryptfs_file_to_lower(file
);
333 if (lower_file
&& lower_file
->f_op
&& lower_file
->f_op
->compat_ioctl
)
334 rc
= lower_file
->f_op
->compat_ioctl(lower_file
, cmd
, arg
);
339 const struct file_operations ecryptfs_dir_fops
= {
340 .readdir
= ecryptfs_readdir
,
341 .read
= generic_read_dir
,
342 .unlocked_ioctl
= ecryptfs_unlocked_ioctl
,
344 .compat_ioctl
= ecryptfs_compat_ioctl
,
346 .open
= ecryptfs_open
,
347 .flush
= ecryptfs_flush
,
348 .release
= ecryptfs_release
,
349 .fsync
= ecryptfs_fsync
,
350 .fasync
= ecryptfs_fasync
,
351 .splice_read
= generic_file_splice_read
,
352 .llseek
= default_llseek
,
355 const struct file_operations ecryptfs_main_fops
= {
356 .llseek
= generic_file_llseek
,
357 .read
= do_sync_read
,
358 .aio_read
= ecryptfs_read_update_atime
,
359 .write
= do_sync_write
,
360 .aio_write
= generic_file_aio_write
,
361 .readdir
= ecryptfs_readdir
,
362 .unlocked_ioctl
= ecryptfs_unlocked_ioctl
,
364 .compat_ioctl
= ecryptfs_compat_ioctl
,
366 .mmap
= generic_file_mmap
,
367 .open
= ecryptfs_open
,
368 .flush
= ecryptfs_flush
,
369 .release
= ecryptfs_release
,
370 .fsync
= ecryptfs_fsync
,
371 .fasync
= ecryptfs_fasync
,
372 .splice_read
= generic_file_splice_read
,