Branch data Line data Source code
1 : : /**
2 : : * eCryptfs: Linux filesystem encryption layer
3 : : *
4 : : * Copyright (C) 1997-2003 Erez Zadok
5 : : * Copyright (C) 2001-2003 Stony Brook University
6 : : * Copyright (C) 2004-2006 International Business Machines Corp.
7 : : * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
8 : : * Michael C. Thompson <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/fs.h>
27 : : #include <linux/mount.h>
28 : : #include <linux/key.h>
29 : : #include <linux/slab.h>
30 : : #include <linux/seq_file.h>
31 : : #include <linux/file.h>
32 : : #include <linux/crypto.h>
33 : : #include <linux/statfs.h>
34 : : #include <linux/magic.h>
35 : : #include "ecryptfs_kernel.h"
36 : :
37 : : struct kmem_cache *ecryptfs_inode_info_cache;
38 : :
39 : : /**
40 : : * ecryptfs_alloc_inode - allocate an ecryptfs inode
41 : : * @sb: Pointer to the ecryptfs super block
42 : : *
43 : : * Called to bring an inode into existence.
44 : : *
45 : : * Only handle allocation, setting up structures should be done in
46 : : * ecryptfs_read_inode. This is because the kernel, between now and
47 : : * then, will 0 out the private data pointer.
48 : : *
49 : : * Returns a pointer to a newly allocated inode, NULL otherwise
50 : : */
51 : 0 : static struct inode *ecryptfs_alloc_inode(struct super_block *sb)
52 : : {
53 : : struct ecryptfs_inode_info *inode_info;
54 : : struct inode *inode = NULL;
55 : :
56 : 0 : inode_info = kmem_cache_alloc(ecryptfs_inode_info_cache, GFP_KERNEL);
57 [ # # ]: 0 : if (unlikely(!inode_info))
58 : : goto out;
59 : 0 : ecryptfs_init_crypt_stat(&inode_info->crypt_stat);
60 : 0 : mutex_init(&inode_info->lower_file_mutex);
61 : 0 : atomic_set(&inode_info->lower_file_count, 0);
62 : 0 : inode_info->lower_file = NULL;
63 : 0 : inode = &inode_info->vfs_inode;
64 : : out:
65 : 0 : return inode;
66 : : }
67 : :
68 : 0 : static void ecryptfs_i_callback(struct rcu_head *head)
69 : : {
70 : : struct inode *inode = container_of(head, struct inode, i_rcu);
71 : : struct ecryptfs_inode_info *inode_info;
72 : 0 : inode_info = ecryptfs_inode_to_private(inode);
73 : :
74 : 0 : kmem_cache_free(ecryptfs_inode_info_cache, inode_info);
75 : 0 : }
76 : :
77 : : /**
78 : : * ecryptfs_destroy_inode
79 : : * @inode: The ecryptfs inode
80 : : *
81 : : * This is used during the final destruction of the inode. All
82 : : * allocation of memory related to the inode, including allocated
83 : : * memory in the crypt_stat struct, will be released here.
84 : : * There should be no chance that this deallocation will be missed.
85 : : */
86 : 0 : static void ecryptfs_destroy_inode(struct inode *inode)
87 : : {
88 : : struct ecryptfs_inode_info *inode_info;
89 : :
90 : : inode_info = ecryptfs_inode_to_private(inode);
91 [ # # ]: 0 : BUG_ON(inode_info->lower_file);
92 : 0 : ecryptfs_destroy_crypt_stat(&inode_info->crypt_stat);
93 : 0 : call_rcu(&inode->i_rcu, ecryptfs_i_callback);
94 : 0 : }
95 : :
96 : : /**
97 : : * ecryptfs_statfs
98 : : * @sb: The ecryptfs super block
99 : : * @buf: The struct kstatfs to fill in with stats
100 : : *
101 : : * Get the filesystem statistics. Currently, we let this pass right through
102 : : * to the lower filesystem and take no action ourselves.
103 : : */
104 : 0 : static int ecryptfs_statfs(struct dentry *dentry, struct kstatfs *buf)
105 : : {
106 : : struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
107 : : int rc;
108 : :
109 [ # # ]: 0 : if (!lower_dentry->d_sb->s_op->statfs)
110 : : return -ENOSYS;
111 : :
112 : 0 : rc = lower_dentry->d_sb->s_op->statfs(lower_dentry, buf);
113 [ # # ]: 0 : if (rc)
114 : : return rc;
115 : :
116 : 0 : buf->f_type = ECRYPTFS_SUPER_MAGIC;
117 : 0 : rc = ecryptfs_set_f_namelen(&buf->f_namelen, buf->f_namelen,
118 : 0 : &ecryptfs_superblock_to_private(dentry->d_sb)->mount_crypt_stat);
119 : :
120 : 0 : return rc;
121 : : }
122 : :
123 : : /**
124 : : * ecryptfs_evict_inode
125 : : * @inode - The ecryptfs inode
126 : : *
127 : : * Called by iput() when the inode reference count reached zero
128 : : * and the inode is not hashed anywhere. Used to clear anything
129 : : * that needs to be, before the inode is completely destroyed and put
130 : : * on the inode free list. We use this to drop out reference to the
131 : : * lower inode.
132 : : */
133 : 0 : static void ecryptfs_evict_inode(struct inode *inode)
134 : : {
135 : 0 : truncate_inode_pages(&inode->i_data, 0);
136 : 0 : clear_inode(inode);
137 : 0 : iput(ecryptfs_inode_to_lower(inode));
138 : 0 : }
139 : :
140 : : /**
141 : : * ecryptfs_show_options
142 : : *
143 : : * Prints the mount options for a given superblock.
144 : : * Returns zero; does not fail.
145 : : */
146 : 0 : static int ecryptfs_show_options(struct seq_file *m, struct dentry *root)
147 : : {
148 : 0 : struct super_block *sb = root->d_sb;
149 : 0 : struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
150 : : &ecryptfs_superblock_to_private(sb)->mount_crypt_stat;
151 : : struct ecryptfs_global_auth_tok *walker;
152 : :
153 : 0 : mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
154 [ # # ]: 0 : list_for_each_entry(walker,
155 : : &mount_crypt_stat->global_auth_tok_list,
156 : : mount_crypt_stat_list) {
157 [ # # ]: 0 : if (walker->flags & ECRYPTFS_AUTH_TOK_FNEK)
158 : 0 : seq_printf(m, ",ecryptfs_fnek_sig=%s", walker->sig);
159 : : else
160 : 0 : seq_printf(m, ",ecryptfs_sig=%s", walker->sig);
161 : : }
162 : 0 : mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
163 : :
164 : 0 : seq_printf(m, ",ecryptfs_cipher=%s",
165 : 0 : mount_crypt_stat->global_default_cipher_name);
166 : :
167 [ # # ]: 0 : if (mount_crypt_stat->global_default_cipher_key_size)
168 : 0 : seq_printf(m, ",ecryptfs_key_bytes=%zd",
169 : : mount_crypt_stat->global_default_cipher_key_size);
170 [ # # ]: 0 : if (mount_crypt_stat->flags & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)
171 : 0 : seq_printf(m, ",ecryptfs_passthrough");
172 [ # # ]: 0 : if (mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED)
173 : 0 : seq_printf(m, ",ecryptfs_xattr_metadata");
174 [ # # ]: 0 : if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
175 : 0 : seq_printf(m, ",ecryptfs_encrypted_view");
176 [ # # ]: 0 : if (mount_crypt_stat->flags & ECRYPTFS_UNLINK_SIGS)
177 : 0 : seq_printf(m, ",ecryptfs_unlink_sigs");
178 [ # # ]: 0 : if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY)
179 : 0 : seq_printf(m, ",ecryptfs_mount_auth_tok_only");
180 : :
181 : 0 : return 0;
182 : : }
183 : :
184 : : const struct super_operations ecryptfs_sops = {
185 : : .alloc_inode = ecryptfs_alloc_inode,
186 : : .destroy_inode = ecryptfs_destroy_inode,
187 : : .statfs = ecryptfs_statfs,
188 : : .remount_fs = NULL,
189 : : .evict_inode = ecryptfs_evict_inode,
190 : : .show_options = ecryptfs_show_options
191 : : };
|
