1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * eCryptfs: Linux filesystem encryption layer |
4 | * |
5 | * Copyright (C) 1997-2003 Erez Zadok |
6 | * Copyright (C) 2001-2003 Stony Brook University |
7 | * Copyright (C) 2004-2007 International Business Machines Corp. |
8 | * Author(s): Michael A. Halcrow <mahalcro@us.ibm.com> |
9 | * Michael C. Thompson <mcthomps@us.ibm.com> |
10 | * Tyler Hicks <code@tyhicks.com> |
11 | */ |
12 | |
13 | #include <linux/dcache.h> |
14 | #include <linux/file.h> |
15 | #include <linux/module.h> |
16 | #include <linux/namei.h> |
17 | #include <linux/skbuff.h> |
18 | #include <linux/mount.h> |
19 | #include <linux/pagemap.h> |
20 | #include <linux/key.h> |
21 | #include <linux/parser.h> |
22 | #include <linux/fs_stack.h> |
23 | #include <linux/slab.h> |
24 | #include <linux/magic.h> |
25 | #include "ecryptfs_kernel.h" |
26 | |
27 | /* |
28 | * Module parameter that defines the ecryptfs_verbosity level. |
29 | */ |
30 | int ecryptfs_verbosity = 0; |
31 | |
32 | module_param(ecryptfs_verbosity, int, 0); |
33 | MODULE_PARM_DESC(ecryptfs_verbosity, |
34 | "Initial verbosity level (0 or 1; defaults to " |
35 | "0, which is Quiet)" ); |
36 | |
37 | /* |
38 | * Module parameter that defines the number of message buffer elements |
39 | */ |
40 | unsigned int ecryptfs_message_buf_len = ECRYPTFS_DEFAULT_MSG_CTX_ELEMS; |
41 | |
42 | module_param(ecryptfs_message_buf_len, uint, 0); |
43 | MODULE_PARM_DESC(ecryptfs_message_buf_len, |
44 | "Number of message buffer elements" ); |
45 | |
46 | /* |
47 | * Module parameter that defines the maximum guaranteed amount of time to wait |
48 | * for a response from ecryptfsd. The actual sleep time will be, more than |
49 | * likely, a small amount greater than this specified value, but only less if |
50 | * the message successfully arrives. |
51 | */ |
52 | signed long ecryptfs_message_wait_timeout = ECRYPTFS_MAX_MSG_CTX_TTL / HZ; |
53 | |
54 | module_param(ecryptfs_message_wait_timeout, long, 0); |
55 | MODULE_PARM_DESC(ecryptfs_message_wait_timeout, |
56 | "Maximum number of seconds that an operation will " |
57 | "sleep while waiting for a message response from " |
58 | "userspace" ); |
59 | |
60 | /* |
61 | * Module parameter that is an estimate of the maximum number of users |
62 | * that will be concurrently using eCryptfs. Set this to the right |
63 | * value to balance performance and memory use. |
64 | */ |
65 | unsigned int ecryptfs_number_of_users = ECRYPTFS_DEFAULT_NUM_USERS; |
66 | |
67 | module_param(ecryptfs_number_of_users, uint, 0); |
68 | MODULE_PARM_DESC(ecryptfs_number_of_users, "An estimate of the number of " |
69 | "concurrent users of eCryptfs" ); |
70 | |
71 | void __ecryptfs_printk(const char *fmt, ...) |
72 | { |
73 | va_list args; |
74 | va_start(args, fmt); |
75 | if (fmt[1] == '7') { /* KERN_DEBUG */ |
76 | if (ecryptfs_verbosity >= 1) |
77 | vprintk(fmt, args); |
78 | } else |
79 | vprintk(fmt, args); |
80 | va_end(args); |
81 | } |
82 | |
83 | /* |
84 | * ecryptfs_init_lower_file |
85 | * @ecryptfs_dentry: Fully initialized eCryptfs dentry object, with |
86 | * the lower dentry and the lower mount set |
87 | * |
88 | * eCryptfs only ever keeps a single open file for every lower |
89 | * inode. All I/O operations to the lower inode occur through that |
90 | * file. When the first eCryptfs dentry that interposes with the first |
91 | * lower dentry for that inode is created, this function creates the |
92 | * lower file struct and associates it with the eCryptfs |
93 | * inode. When all eCryptfs files associated with the inode are released, the |
94 | * file is closed. |
95 | * |
96 | * The lower file will be opened with read/write permissions, if |
97 | * possible. Otherwise, it is opened read-only. |
98 | * |
99 | * This function does nothing if a lower file is already |
100 | * associated with the eCryptfs inode. |
101 | * |
102 | * Returns zero on success; non-zero otherwise |
103 | */ |
104 | static int ecryptfs_init_lower_file(struct dentry *dentry, |
105 | struct file **lower_file) |
106 | { |
107 | const struct cred *cred = current_cred(); |
108 | const struct path *path = ecryptfs_dentry_to_lower_path(dentry); |
109 | int rc; |
110 | |
111 | rc = ecryptfs_privileged_open(lower_file, lower_dentry: path->dentry, lower_mnt: path->mnt, |
112 | cred); |
113 | if (rc) { |
114 | printk(KERN_ERR "Error opening lower file " |
115 | "for lower_dentry [0x%p] and lower_mnt [0x%p]; " |
116 | "rc = [%d]\n" , path->dentry, path->mnt, rc); |
117 | (*lower_file) = NULL; |
118 | } |
119 | return rc; |
120 | } |
121 | |
122 | int ecryptfs_get_lower_file(struct dentry *dentry, struct inode *inode) |
123 | { |
124 | struct ecryptfs_inode_info *inode_info; |
125 | int count, rc = 0; |
126 | |
127 | inode_info = ecryptfs_inode_to_private(inode); |
128 | mutex_lock(&inode_info->lower_file_mutex); |
129 | count = atomic_inc_return(v: &inode_info->lower_file_count); |
130 | if (WARN_ON_ONCE(count < 1)) |
131 | rc = -EINVAL; |
132 | else if (count == 1) { |
133 | rc = ecryptfs_init_lower_file(dentry, |
134 | lower_file: &inode_info->lower_file); |
135 | if (rc) |
136 | atomic_set(v: &inode_info->lower_file_count, i: 0); |
137 | } |
138 | mutex_unlock(lock: &inode_info->lower_file_mutex); |
139 | return rc; |
140 | } |
141 | |
142 | void ecryptfs_put_lower_file(struct inode *inode) |
143 | { |
144 | struct ecryptfs_inode_info *inode_info; |
145 | |
146 | inode_info = ecryptfs_inode_to_private(inode); |
147 | if (atomic_dec_and_mutex_lock(cnt: &inode_info->lower_file_count, |
148 | lock: &inode_info->lower_file_mutex)) { |
149 | filemap_write_and_wait(mapping: inode->i_mapping); |
150 | fput(inode_info->lower_file); |
151 | inode_info->lower_file = NULL; |
152 | mutex_unlock(lock: &inode_info->lower_file_mutex); |
153 | } |
154 | } |
155 | |
156 | enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig, |
157 | ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher, |
158 | ecryptfs_opt_ecryptfs_key_bytes, |
159 | ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata, |
160 | ecryptfs_opt_encrypted_view, ecryptfs_opt_fnek_sig, |
161 | ecryptfs_opt_fn_cipher, ecryptfs_opt_fn_cipher_key_bytes, |
162 | ecryptfs_opt_unlink_sigs, ecryptfs_opt_mount_auth_tok_only, |
163 | ecryptfs_opt_check_dev_ruid, |
164 | ecryptfs_opt_err }; |
165 | |
166 | static const match_table_t tokens = { |
167 | {ecryptfs_opt_sig, "sig=%s" }, |
168 | {ecryptfs_opt_ecryptfs_sig, "ecryptfs_sig=%s" }, |
169 | {ecryptfs_opt_cipher, "cipher=%s" }, |
170 | {ecryptfs_opt_ecryptfs_cipher, "ecryptfs_cipher=%s" }, |
171 | {ecryptfs_opt_ecryptfs_key_bytes, "ecryptfs_key_bytes=%u" }, |
172 | {ecryptfs_opt_passthrough, "ecryptfs_passthrough" }, |
173 | {ecryptfs_opt_xattr_metadata, "ecryptfs_xattr_metadata" }, |
174 | {ecryptfs_opt_encrypted_view, "ecryptfs_encrypted_view" }, |
175 | {ecryptfs_opt_fnek_sig, "ecryptfs_fnek_sig=%s" }, |
176 | {ecryptfs_opt_fn_cipher, "ecryptfs_fn_cipher=%s" }, |
177 | {ecryptfs_opt_fn_cipher_key_bytes, "ecryptfs_fn_key_bytes=%u" }, |
178 | {ecryptfs_opt_unlink_sigs, "ecryptfs_unlink_sigs" }, |
179 | {ecryptfs_opt_mount_auth_tok_only, "ecryptfs_mount_auth_tok_only" }, |
180 | {ecryptfs_opt_check_dev_ruid, "ecryptfs_check_dev_ruid" }, |
181 | {ecryptfs_opt_err, NULL} |
182 | }; |
183 | |
184 | static int ecryptfs_init_global_auth_toks( |
185 | struct ecryptfs_mount_crypt_stat *mount_crypt_stat) |
186 | { |
187 | struct ecryptfs_global_auth_tok *global_auth_tok; |
188 | struct ecryptfs_auth_tok *auth_tok; |
189 | int rc = 0; |
190 | |
191 | list_for_each_entry(global_auth_tok, |
192 | &mount_crypt_stat->global_auth_tok_list, |
193 | mount_crypt_stat_list) { |
194 | rc = ecryptfs_keyring_auth_tok_for_sig( |
195 | auth_tok_key: &global_auth_tok->global_auth_tok_key, auth_tok: &auth_tok, |
196 | sig: global_auth_tok->sig); |
197 | if (rc) { |
198 | printk(KERN_ERR "Could not find valid key in user " |
199 | "session keyring for sig specified in mount " |
200 | "option: [%s]\n" , global_auth_tok->sig); |
201 | global_auth_tok->flags |= ECRYPTFS_AUTH_TOK_INVALID; |
202 | goto out; |
203 | } else { |
204 | global_auth_tok->flags &= ~ECRYPTFS_AUTH_TOK_INVALID; |
205 | up_write(sem: &(global_auth_tok->global_auth_tok_key)->sem); |
206 | } |
207 | } |
208 | out: |
209 | return rc; |
210 | } |
211 | |
212 | static void ecryptfs_init_mount_crypt_stat( |
213 | struct ecryptfs_mount_crypt_stat *mount_crypt_stat) |
214 | { |
215 | memset((void *)mount_crypt_stat, 0, |
216 | sizeof(struct ecryptfs_mount_crypt_stat)); |
217 | INIT_LIST_HEAD(list: &mount_crypt_stat->global_auth_tok_list); |
218 | mutex_init(&mount_crypt_stat->global_auth_tok_list_mutex); |
219 | mount_crypt_stat->flags |= ECRYPTFS_MOUNT_CRYPT_STAT_INITIALIZED; |
220 | } |
221 | |
222 | /** |
223 | * ecryptfs_parse_options |
224 | * @sbi: The ecryptfs super block |
225 | * @options: The options passed to the kernel |
226 | * @check_ruid: set to 1 if device uid should be checked against the ruid |
227 | * |
228 | * Parse mount options: |
229 | * debug=N - ecryptfs_verbosity level for debug output |
230 | * sig=XXX - description(signature) of the key to use |
231 | * |
232 | * Returns the dentry object of the lower-level (lower/interposed) |
233 | * directory; We want to mount our stackable file system on top of |
234 | * that lower directory. |
235 | * |
236 | * The signature of the key to use must be the description of a key |
237 | * already in the keyring. Mounting will fail if the key can not be |
238 | * found. |
239 | * |
240 | * Returns zero on success; non-zero on error |
241 | */ |
242 | static int ecryptfs_parse_options(struct ecryptfs_sb_info *sbi, char *options, |
243 | uid_t *check_ruid) |
244 | { |
245 | char *p; |
246 | int rc = 0; |
247 | int sig_set = 0; |
248 | int cipher_name_set = 0; |
249 | int fn_cipher_name_set = 0; |
250 | int cipher_key_bytes; |
251 | int cipher_key_bytes_set = 0; |
252 | int fn_cipher_key_bytes; |
253 | int fn_cipher_key_bytes_set = 0; |
254 | struct ecryptfs_mount_crypt_stat *mount_crypt_stat = |
255 | &sbi->mount_crypt_stat; |
256 | substring_t args[MAX_OPT_ARGS]; |
257 | int token; |
258 | char *sig_src; |
259 | char *cipher_name_dst; |
260 | char *cipher_name_src; |
261 | char *fn_cipher_name_dst; |
262 | char *fn_cipher_name_src; |
263 | char *fnek_dst; |
264 | char *fnek_src; |
265 | char *cipher_key_bytes_src; |
266 | char *fn_cipher_key_bytes_src; |
267 | u8 cipher_code; |
268 | |
269 | *check_ruid = 0; |
270 | |
271 | if (!options) { |
272 | rc = -EINVAL; |
273 | goto out; |
274 | } |
275 | ecryptfs_init_mount_crypt_stat(mount_crypt_stat); |
276 | while ((p = strsep(&options, "," )) != NULL) { |
277 | if (!*p) |
278 | continue; |
279 | token = match_token(p, table: tokens, args); |
280 | switch (token) { |
281 | case ecryptfs_opt_sig: |
282 | case ecryptfs_opt_ecryptfs_sig: |
283 | sig_src = args[0].from; |
284 | rc = ecryptfs_add_global_auth_tok(mount_crypt_stat, |
285 | sig: sig_src, global_auth_tok_flags: 0); |
286 | if (rc) { |
287 | printk(KERN_ERR "Error attempting to register " |
288 | "global sig; rc = [%d]\n" , rc); |
289 | goto out; |
290 | } |
291 | sig_set = 1; |
292 | break; |
293 | case ecryptfs_opt_cipher: |
294 | case ecryptfs_opt_ecryptfs_cipher: |
295 | cipher_name_src = args[0].from; |
296 | cipher_name_dst = |
297 | mount_crypt_stat-> |
298 | global_default_cipher_name; |
299 | strncpy(p: cipher_name_dst, q: cipher_name_src, |
300 | ECRYPTFS_MAX_CIPHER_NAME_SIZE); |
301 | cipher_name_dst[ECRYPTFS_MAX_CIPHER_NAME_SIZE] = '\0'; |
302 | cipher_name_set = 1; |
303 | break; |
304 | case ecryptfs_opt_ecryptfs_key_bytes: |
305 | cipher_key_bytes_src = args[0].from; |
306 | cipher_key_bytes = |
307 | (int)simple_strtol(cipher_key_bytes_src, |
308 | &cipher_key_bytes_src, 0); |
309 | mount_crypt_stat->global_default_cipher_key_size = |
310 | cipher_key_bytes; |
311 | cipher_key_bytes_set = 1; |
312 | break; |
313 | case ecryptfs_opt_passthrough: |
314 | mount_crypt_stat->flags |= |
315 | ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED; |
316 | break; |
317 | case ecryptfs_opt_xattr_metadata: |
318 | mount_crypt_stat->flags |= |
319 | ECRYPTFS_XATTR_METADATA_ENABLED; |
320 | break; |
321 | case ecryptfs_opt_encrypted_view: |
322 | mount_crypt_stat->flags |= |
323 | ECRYPTFS_XATTR_METADATA_ENABLED; |
324 | mount_crypt_stat->flags |= |
325 | ECRYPTFS_ENCRYPTED_VIEW_ENABLED; |
326 | break; |
327 | case ecryptfs_opt_fnek_sig: |
328 | fnek_src = args[0].from; |
329 | fnek_dst = |
330 | mount_crypt_stat->global_default_fnek_sig; |
331 | strncpy(p: fnek_dst, q: fnek_src, ECRYPTFS_SIG_SIZE_HEX); |
332 | mount_crypt_stat->global_default_fnek_sig[ |
333 | ECRYPTFS_SIG_SIZE_HEX] = '\0'; |
334 | rc = ecryptfs_add_global_auth_tok( |
335 | mount_crypt_stat, |
336 | sig: mount_crypt_stat->global_default_fnek_sig, |
337 | ECRYPTFS_AUTH_TOK_FNEK); |
338 | if (rc) { |
339 | printk(KERN_ERR "Error attempting to register " |
340 | "global fnek sig [%s]; rc = [%d]\n" , |
341 | mount_crypt_stat->global_default_fnek_sig, |
342 | rc); |
343 | goto out; |
344 | } |
345 | mount_crypt_stat->flags |= |
346 | (ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES |
347 | | ECRYPTFS_GLOBAL_ENCFN_USE_MOUNT_FNEK); |
348 | break; |
349 | case ecryptfs_opt_fn_cipher: |
350 | fn_cipher_name_src = args[0].from; |
351 | fn_cipher_name_dst = |
352 | mount_crypt_stat->global_default_fn_cipher_name; |
353 | strncpy(p: fn_cipher_name_dst, q: fn_cipher_name_src, |
354 | ECRYPTFS_MAX_CIPHER_NAME_SIZE); |
355 | mount_crypt_stat->global_default_fn_cipher_name[ |
356 | ECRYPTFS_MAX_CIPHER_NAME_SIZE] = '\0'; |
357 | fn_cipher_name_set = 1; |
358 | break; |
359 | case ecryptfs_opt_fn_cipher_key_bytes: |
360 | fn_cipher_key_bytes_src = args[0].from; |
361 | fn_cipher_key_bytes = |
362 | (int)simple_strtol(fn_cipher_key_bytes_src, |
363 | &fn_cipher_key_bytes_src, 0); |
364 | mount_crypt_stat->global_default_fn_cipher_key_bytes = |
365 | fn_cipher_key_bytes; |
366 | fn_cipher_key_bytes_set = 1; |
367 | break; |
368 | case ecryptfs_opt_unlink_sigs: |
369 | mount_crypt_stat->flags |= ECRYPTFS_UNLINK_SIGS; |
370 | break; |
371 | case ecryptfs_opt_mount_auth_tok_only: |
372 | mount_crypt_stat->flags |= |
373 | ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY; |
374 | break; |
375 | case ecryptfs_opt_check_dev_ruid: |
376 | *check_ruid = 1; |
377 | break; |
378 | case ecryptfs_opt_err: |
379 | default: |
380 | printk(KERN_WARNING |
381 | "%s: eCryptfs: unrecognized option [%s]\n" , |
382 | __func__, p); |
383 | } |
384 | } |
385 | if (!sig_set) { |
386 | rc = -EINVAL; |
387 | ecryptfs_printk(KERN_ERR, "You must supply at least one valid " |
388 | "auth tok signature as a mount " |
389 | "parameter; see the eCryptfs README\n" ); |
390 | goto out; |
391 | } |
392 | if (!cipher_name_set) { |
393 | int cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER); |
394 | |
395 | BUG_ON(cipher_name_len > ECRYPTFS_MAX_CIPHER_NAME_SIZE); |
396 | strcpy(p: mount_crypt_stat->global_default_cipher_name, |
397 | ECRYPTFS_DEFAULT_CIPHER); |
398 | } |
399 | if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) |
400 | && !fn_cipher_name_set) |
401 | strcpy(p: mount_crypt_stat->global_default_fn_cipher_name, |
402 | q: mount_crypt_stat->global_default_cipher_name); |
403 | if (!cipher_key_bytes_set) |
404 | mount_crypt_stat->global_default_cipher_key_size = 0; |
405 | if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) |
406 | && !fn_cipher_key_bytes_set) |
407 | mount_crypt_stat->global_default_fn_cipher_key_bytes = |
408 | mount_crypt_stat->global_default_cipher_key_size; |
409 | |
410 | cipher_code = ecryptfs_code_for_cipher_string( |
411 | cipher_name: mount_crypt_stat->global_default_cipher_name, |
412 | key_bytes: mount_crypt_stat->global_default_cipher_key_size); |
413 | if (!cipher_code) { |
414 | ecryptfs_printk(KERN_ERR, |
415 | "eCryptfs doesn't support cipher: %s\n" , |
416 | mount_crypt_stat->global_default_cipher_name); |
417 | rc = -EINVAL; |
418 | goto out; |
419 | } |
420 | |
421 | mutex_lock(&key_tfm_list_mutex); |
422 | if (!ecryptfs_tfm_exists(cipher_name: mount_crypt_stat->global_default_cipher_name, |
423 | NULL)) { |
424 | rc = ecryptfs_add_new_key_tfm( |
425 | NULL, cipher_name: mount_crypt_stat->global_default_cipher_name, |
426 | key_size: mount_crypt_stat->global_default_cipher_key_size); |
427 | if (rc) { |
428 | printk(KERN_ERR "Error attempting to initialize " |
429 | "cipher with name = [%s] and key size = [%td]; " |
430 | "rc = [%d]\n" , |
431 | mount_crypt_stat->global_default_cipher_name, |
432 | mount_crypt_stat->global_default_cipher_key_size, |
433 | rc); |
434 | rc = -EINVAL; |
435 | mutex_unlock(lock: &key_tfm_list_mutex); |
436 | goto out; |
437 | } |
438 | } |
439 | if ((mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) |
440 | && !ecryptfs_tfm_exists( |
441 | cipher_name: mount_crypt_stat->global_default_fn_cipher_name, NULL)) { |
442 | rc = ecryptfs_add_new_key_tfm( |
443 | NULL, cipher_name: mount_crypt_stat->global_default_fn_cipher_name, |
444 | key_size: mount_crypt_stat->global_default_fn_cipher_key_bytes); |
445 | if (rc) { |
446 | printk(KERN_ERR "Error attempting to initialize " |
447 | "cipher with name = [%s] and key size = [%td]; " |
448 | "rc = [%d]\n" , |
449 | mount_crypt_stat->global_default_fn_cipher_name, |
450 | mount_crypt_stat->global_default_fn_cipher_key_bytes, |
451 | rc); |
452 | rc = -EINVAL; |
453 | mutex_unlock(lock: &key_tfm_list_mutex); |
454 | goto out; |
455 | } |
456 | } |
457 | mutex_unlock(lock: &key_tfm_list_mutex); |
458 | rc = ecryptfs_init_global_auth_toks(mount_crypt_stat); |
459 | if (rc) |
460 | printk(KERN_WARNING "One or more global auth toks could not " |
461 | "properly register; rc = [%d]\n" , rc); |
462 | out: |
463 | return rc; |
464 | } |
465 | |
466 | struct kmem_cache *ecryptfs_sb_info_cache; |
467 | static struct file_system_type ecryptfs_fs_type; |
468 | |
469 | /* |
470 | * ecryptfs_mount |
471 | * @fs_type: The filesystem type that the superblock should belong to |
472 | * @flags: The flags associated with the mount |
473 | * @dev_name: The path to mount over |
474 | * @raw_data: The options passed into the kernel |
475 | */ |
476 | static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags, |
477 | const char *dev_name, void *raw_data) |
478 | { |
479 | struct super_block *s; |
480 | struct ecryptfs_sb_info *sbi; |
481 | struct ecryptfs_mount_crypt_stat *mount_crypt_stat; |
482 | struct ecryptfs_dentry_info *root_info; |
483 | const char *err = "Getting sb failed" ; |
484 | struct inode *inode; |
485 | struct path path; |
486 | uid_t check_ruid; |
487 | int rc; |
488 | |
489 | sbi = kmem_cache_zalloc(k: ecryptfs_sb_info_cache, GFP_KERNEL); |
490 | if (!sbi) { |
491 | rc = -ENOMEM; |
492 | goto out; |
493 | } |
494 | |
495 | if (!dev_name) { |
496 | rc = -EINVAL; |
497 | err = "Device name cannot be null" ; |
498 | goto out; |
499 | } |
500 | |
501 | rc = ecryptfs_parse_options(sbi, options: raw_data, check_ruid: &check_ruid); |
502 | if (rc) { |
503 | err = "Error parsing options" ; |
504 | goto out; |
505 | } |
506 | mount_crypt_stat = &sbi->mount_crypt_stat; |
507 | |
508 | s = sget(type: fs_type, NULL, set: set_anon_super, flags, NULL); |
509 | if (IS_ERR(ptr: s)) { |
510 | rc = PTR_ERR(ptr: s); |
511 | goto out; |
512 | } |
513 | |
514 | rc = super_setup_bdi(sb: s); |
515 | if (rc) |
516 | goto out1; |
517 | |
518 | ecryptfs_set_superblock_private(sb: s, sb_info: sbi); |
519 | |
520 | /* ->kill_sb() will take care of sbi after that point */ |
521 | sbi = NULL; |
522 | s->s_op = &ecryptfs_sops; |
523 | s->s_xattr = ecryptfs_xattr_handlers; |
524 | s->s_d_op = &ecryptfs_dops; |
525 | |
526 | err = "Reading sb failed" ; |
527 | rc = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path); |
528 | if (rc) { |
529 | ecryptfs_printk(KERN_WARNING, "kern_path() failed\n" ); |
530 | goto out1; |
531 | } |
532 | if (path.dentry->d_sb->s_type == &ecryptfs_fs_type) { |
533 | rc = -EINVAL; |
534 | printk(KERN_ERR "Mount on filesystem of type " |
535 | "eCryptfs explicitly disallowed due to " |
536 | "known incompatibilities\n" ); |
537 | goto out_free; |
538 | } |
539 | |
540 | if (is_idmapped_mnt(mnt: path.mnt)) { |
541 | rc = -EINVAL; |
542 | printk(KERN_ERR "Mounting on idmapped mounts currently disallowed\n" ); |
543 | goto out_free; |
544 | } |
545 | |
546 | if (check_ruid && !uid_eq(left: d_inode(dentry: path.dentry)->i_uid, current_uid())) { |
547 | rc = -EPERM; |
548 | printk(KERN_ERR "Mount of device (uid: %d) not owned by " |
549 | "requested user (uid: %d)\n" , |
550 | i_uid_read(d_inode(path.dentry)), |
551 | from_kuid(&init_user_ns, current_uid())); |
552 | goto out_free; |
553 | } |
554 | |
555 | ecryptfs_set_superblock_lower(sb: s, lower_sb: path.dentry->d_sb); |
556 | |
557 | /** |
558 | * Set the POSIX ACL flag based on whether they're enabled in the lower |
559 | * mount. |
560 | */ |
561 | s->s_flags = flags & ~SB_POSIXACL; |
562 | s->s_flags |= path.dentry->d_sb->s_flags & SB_POSIXACL; |
563 | |
564 | /** |
565 | * Force a read-only eCryptfs mount when: |
566 | * 1) The lower mount is ro |
567 | * 2) The ecryptfs_encrypted_view mount option is specified |
568 | */ |
569 | if (sb_rdonly(sb: path.dentry->d_sb) || mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED) |
570 | s->s_flags |= SB_RDONLY; |
571 | |
572 | s->s_maxbytes = path.dentry->d_sb->s_maxbytes; |
573 | s->s_blocksize = path.dentry->d_sb->s_blocksize; |
574 | s->s_magic = ECRYPTFS_SUPER_MAGIC; |
575 | s->s_stack_depth = path.dentry->d_sb->s_stack_depth + 1; |
576 | |
577 | rc = -EINVAL; |
578 | if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { |
579 | pr_err("eCryptfs: maximum fs stacking depth exceeded\n" ); |
580 | goto out_free; |
581 | } |
582 | |
583 | inode = ecryptfs_get_inode(lower_inode: d_inode(dentry: path.dentry), sb: s); |
584 | rc = PTR_ERR(ptr: inode); |
585 | if (IS_ERR(ptr: inode)) |
586 | goto out_free; |
587 | |
588 | s->s_root = d_make_root(inode); |
589 | if (!s->s_root) { |
590 | rc = -ENOMEM; |
591 | goto out_free; |
592 | } |
593 | |
594 | rc = -ENOMEM; |
595 | root_info = kmem_cache_zalloc(k: ecryptfs_dentry_info_cache, GFP_KERNEL); |
596 | if (!root_info) |
597 | goto out_free; |
598 | |
599 | /* ->kill_sb() will take care of root_info */ |
600 | ecryptfs_set_dentry_private(dentry: s->s_root, dentry_info: root_info); |
601 | root_info->lower_path = path; |
602 | |
603 | s->s_flags |= SB_ACTIVE; |
604 | return dget(dentry: s->s_root); |
605 | |
606 | out_free: |
607 | path_put(&path); |
608 | out1: |
609 | deactivate_locked_super(sb: s); |
610 | out: |
611 | if (sbi) { |
612 | ecryptfs_destroy_mount_crypt_stat(mount_crypt_stat: &sbi->mount_crypt_stat); |
613 | kmem_cache_free(s: ecryptfs_sb_info_cache, objp: sbi); |
614 | } |
615 | printk(KERN_ERR "%s; rc = [%d]\n" , err, rc); |
616 | return ERR_PTR(error: rc); |
617 | } |
618 | |
619 | /** |
620 | * ecryptfs_kill_block_super |
621 | * @sb: The ecryptfs super block |
622 | * |
623 | * Used to bring the superblock down and free the private data. |
624 | */ |
625 | static void ecryptfs_kill_block_super(struct super_block *sb) |
626 | { |
627 | struct ecryptfs_sb_info *sb_info = ecryptfs_superblock_to_private(sb); |
628 | kill_anon_super(sb); |
629 | if (!sb_info) |
630 | return; |
631 | ecryptfs_destroy_mount_crypt_stat(mount_crypt_stat: &sb_info->mount_crypt_stat); |
632 | kmem_cache_free(s: ecryptfs_sb_info_cache, objp: sb_info); |
633 | } |
634 | |
635 | static struct file_system_type ecryptfs_fs_type = { |
636 | .owner = THIS_MODULE, |
637 | .name = "ecryptfs" , |
638 | .mount = ecryptfs_mount, |
639 | .kill_sb = ecryptfs_kill_block_super, |
640 | .fs_flags = 0 |
641 | }; |
642 | MODULE_ALIAS_FS("ecryptfs" ); |
643 | |
644 | /* |
645 | * inode_info_init_once |
646 | * |
647 | * Initializes the ecryptfs_inode_info_cache when it is created |
648 | */ |
649 | static void |
650 | inode_info_init_once(void *vptr) |
651 | { |
652 | struct ecryptfs_inode_info *ei = (struct ecryptfs_inode_info *)vptr; |
653 | |
654 | inode_init_once(&ei->vfs_inode); |
655 | } |
656 | |
657 | static struct ecryptfs_cache_info { |
658 | struct kmem_cache **cache; |
659 | const char *name; |
660 | size_t size; |
661 | slab_flags_t flags; |
662 | void (*ctor)(void *obj); |
663 | } ecryptfs_cache_infos[] = { |
664 | { |
665 | .cache = &ecryptfs_auth_tok_list_item_cache, |
666 | .name = "ecryptfs_auth_tok_list_item" , |
667 | .size = sizeof(struct ecryptfs_auth_tok_list_item), |
668 | }, |
669 | { |
670 | .cache = &ecryptfs_file_info_cache, |
671 | .name = "ecryptfs_file_cache" , |
672 | .size = sizeof(struct ecryptfs_file_info), |
673 | }, |
674 | { |
675 | .cache = &ecryptfs_dentry_info_cache, |
676 | .name = "ecryptfs_dentry_info_cache" , |
677 | .size = sizeof(struct ecryptfs_dentry_info), |
678 | }, |
679 | { |
680 | .cache = &ecryptfs_inode_info_cache, |
681 | .name = "ecryptfs_inode_cache" , |
682 | .size = sizeof(struct ecryptfs_inode_info), |
683 | .flags = SLAB_ACCOUNT, |
684 | .ctor = inode_info_init_once, |
685 | }, |
686 | { |
687 | .cache = &ecryptfs_sb_info_cache, |
688 | .name = "ecryptfs_sb_cache" , |
689 | .size = sizeof(struct ecryptfs_sb_info), |
690 | }, |
691 | { |
692 | .cache = &ecryptfs_header_cache, |
693 | .name = "ecryptfs_headers" , |
694 | .size = PAGE_SIZE, |
695 | }, |
696 | { |
697 | .cache = &ecryptfs_xattr_cache, |
698 | .name = "ecryptfs_xattr_cache" , |
699 | .size = PAGE_SIZE, |
700 | }, |
701 | { |
702 | .cache = &ecryptfs_key_record_cache, |
703 | .name = "ecryptfs_key_record_cache" , |
704 | .size = sizeof(struct ecryptfs_key_record), |
705 | }, |
706 | { |
707 | .cache = &ecryptfs_key_sig_cache, |
708 | .name = "ecryptfs_key_sig_cache" , |
709 | .size = sizeof(struct ecryptfs_key_sig), |
710 | }, |
711 | { |
712 | .cache = &ecryptfs_global_auth_tok_cache, |
713 | .name = "ecryptfs_global_auth_tok_cache" , |
714 | .size = sizeof(struct ecryptfs_global_auth_tok), |
715 | }, |
716 | { |
717 | .cache = &ecryptfs_key_tfm_cache, |
718 | .name = "ecryptfs_key_tfm_cache" , |
719 | .size = sizeof(struct ecryptfs_key_tfm), |
720 | }, |
721 | }; |
722 | |
723 | static void ecryptfs_free_kmem_caches(void) |
724 | { |
725 | int i; |
726 | |
727 | /* |
728 | * Make sure all delayed rcu free inodes are flushed before we |
729 | * destroy cache. |
730 | */ |
731 | rcu_barrier(); |
732 | |
733 | for (i = 0; i < ARRAY_SIZE(ecryptfs_cache_infos); i++) { |
734 | struct ecryptfs_cache_info *info; |
735 | |
736 | info = &ecryptfs_cache_infos[i]; |
737 | kmem_cache_destroy(s: *(info->cache)); |
738 | } |
739 | } |
740 | |
741 | /** |
742 | * ecryptfs_init_kmem_caches |
743 | * |
744 | * Returns zero on success; non-zero otherwise |
745 | */ |
746 | static int ecryptfs_init_kmem_caches(void) |
747 | { |
748 | int i; |
749 | |
750 | for (i = 0; i < ARRAY_SIZE(ecryptfs_cache_infos); i++) { |
751 | struct ecryptfs_cache_info *info; |
752 | |
753 | info = &ecryptfs_cache_infos[i]; |
754 | *(info->cache) = kmem_cache_create(name: info->name, size: info->size, align: 0, |
755 | SLAB_HWCACHE_ALIGN | info->flags, ctor: info->ctor); |
756 | if (!*(info->cache)) { |
757 | ecryptfs_free_kmem_caches(); |
758 | ecryptfs_printk(KERN_WARNING, "%s: " |
759 | "kmem_cache_create failed\n" , |
760 | info->name); |
761 | return -ENOMEM; |
762 | } |
763 | } |
764 | return 0; |
765 | } |
766 | |
767 | static struct kobject *ecryptfs_kobj; |
768 | |
769 | static ssize_t version_show(struct kobject *kobj, |
770 | struct kobj_attribute *attr, char *buff) |
771 | { |
772 | return snprintf(buf: buff, PAGE_SIZE, fmt: "%d\n" , ECRYPTFS_VERSIONING_MASK); |
773 | } |
774 | |
775 | static struct kobj_attribute version_attr = __ATTR_RO(version); |
776 | |
777 | static struct attribute *attributes[] = { |
778 | &version_attr.attr, |
779 | NULL, |
780 | }; |
781 | |
782 | static const struct attribute_group attr_group = { |
783 | .attrs = attributes, |
784 | }; |
785 | |
786 | static int do_sysfs_registration(void) |
787 | { |
788 | int rc; |
789 | |
790 | ecryptfs_kobj = kobject_create_and_add(name: "ecryptfs" , parent: fs_kobj); |
791 | if (!ecryptfs_kobj) { |
792 | printk(KERN_ERR "Unable to create ecryptfs kset\n" ); |
793 | rc = -ENOMEM; |
794 | goto out; |
795 | } |
796 | rc = sysfs_create_group(kobj: ecryptfs_kobj, grp: &attr_group); |
797 | if (rc) { |
798 | printk(KERN_ERR |
799 | "Unable to create ecryptfs version attributes\n" ); |
800 | kobject_put(kobj: ecryptfs_kobj); |
801 | } |
802 | out: |
803 | return rc; |
804 | } |
805 | |
806 | static void do_sysfs_unregistration(void) |
807 | { |
808 | sysfs_remove_group(kobj: ecryptfs_kobj, grp: &attr_group); |
809 | kobject_put(kobj: ecryptfs_kobj); |
810 | } |
811 | |
812 | static int __init ecryptfs_init(void) |
813 | { |
814 | int rc; |
815 | |
816 | if (ECRYPTFS_DEFAULT_EXTENT_SIZE > PAGE_SIZE) { |
817 | rc = -EINVAL; |
818 | ecryptfs_printk(KERN_ERR, "The eCryptfs extent size is " |
819 | "larger than the host's page size, and so " |
820 | "eCryptfs cannot run on this system. The " |
821 | "default eCryptfs extent size is [%u] bytes; " |
822 | "the page size is [%lu] bytes.\n" , |
823 | ECRYPTFS_DEFAULT_EXTENT_SIZE, |
824 | (unsigned long)PAGE_SIZE); |
825 | goto out; |
826 | } |
827 | rc = ecryptfs_init_kmem_caches(); |
828 | if (rc) { |
829 | printk(KERN_ERR |
830 | "Failed to allocate one or more kmem_cache objects\n" ); |
831 | goto out; |
832 | } |
833 | rc = do_sysfs_registration(); |
834 | if (rc) { |
835 | printk(KERN_ERR "sysfs registration failed\n" ); |
836 | goto out_free_kmem_caches; |
837 | } |
838 | rc = ecryptfs_init_kthread(); |
839 | if (rc) { |
840 | printk(KERN_ERR "%s: kthread initialization failed; " |
841 | "rc = [%d]\n" , __func__, rc); |
842 | goto out_do_sysfs_unregistration; |
843 | } |
844 | rc = ecryptfs_init_messaging(); |
845 | if (rc) { |
846 | printk(KERN_ERR "Failure occurred while attempting to " |
847 | "initialize the communications channel to " |
848 | "ecryptfsd\n" ); |
849 | goto out_destroy_kthread; |
850 | } |
851 | rc = ecryptfs_init_crypto(); |
852 | if (rc) { |
853 | printk(KERN_ERR "Failure whilst attempting to init crypto; " |
854 | "rc = [%d]\n" , rc); |
855 | goto out_release_messaging; |
856 | } |
857 | rc = register_filesystem(&ecryptfs_fs_type); |
858 | if (rc) { |
859 | printk(KERN_ERR "Failed to register filesystem\n" ); |
860 | goto out_destroy_crypto; |
861 | } |
862 | if (ecryptfs_verbosity > 0) |
863 | printk(KERN_CRIT "eCryptfs verbosity set to %d. Secret values " |
864 | "will be written to the syslog!\n" , ecryptfs_verbosity); |
865 | |
866 | goto out; |
867 | out_destroy_crypto: |
868 | ecryptfs_destroy_crypto(); |
869 | out_release_messaging: |
870 | ecryptfs_release_messaging(); |
871 | out_destroy_kthread: |
872 | ecryptfs_destroy_kthread(); |
873 | out_do_sysfs_unregistration: |
874 | do_sysfs_unregistration(); |
875 | out_free_kmem_caches: |
876 | ecryptfs_free_kmem_caches(); |
877 | out: |
878 | return rc; |
879 | } |
880 | |
881 | static void __exit ecryptfs_exit(void) |
882 | { |
883 | int rc; |
884 | |
885 | rc = ecryptfs_destroy_crypto(); |
886 | if (rc) |
887 | printk(KERN_ERR "Failure whilst attempting to destroy crypto; " |
888 | "rc = [%d]\n" , rc); |
889 | ecryptfs_release_messaging(); |
890 | ecryptfs_destroy_kthread(); |
891 | do_sysfs_unregistration(); |
892 | unregister_filesystem(&ecryptfs_fs_type); |
893 | ecryptfs_free_kmem_caches(); |
894 | } |
895 | |
896 | MODULE_AUTHOR("Michael A. Halcrow <mhalcrow@us.ibm.com>" ); |
897 | MODULE_DESCRIPTION("eCryptfs" ); |
898 | |
899 | MODULE_LICENSE("GPL" ); |
900 | |
901 | module_init(ecryptfs_init) |
902 | module_exit(ecryptfs_exit) |
903 | |