| Linux kernel & device driver programming |
| [ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] |
1 /** 1
2 * eCryptfs: Linux filesystem encryption layer
3 *
4 * Copyright (C) 1997-2003 Erez Zadok
5 * Copyright (C) 2001-2003 Stony Brook Univers
6 * Copyright (C) 2004-2007 International Busin
7 * Author(s): Michael A. Halcrow <mahalcro@u
8 * Michael C. Thompson <mcthomps@
9 * Tyler Hicks <tyhicks@ou.edu>
10 *
11 * This program is free software; you can redi
12 * modify it under the terms of the GNU Genera
13 * published by the Free Software Foundation;
14 * License, or (at your option) any later vers
15 *
16 * This program is distributed in the hope tha
17 * WITHOUT ANY WARRANTY; without even the impl
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU
22 * along with this program; if not, write to t
23 * Foundation, Inc., 59 Temple Place - Suite 3
24 * 02111-1307, USA.
25 */
26
27 #include <linux/dcache.h>
28 #include <linux/file.h>
29 #include <linux/module.h>
30 #include <linux/namei.h>
31 #include <linux/skbuff.h>
32 #include <linux/crypto.h>
33 #include <linux/netlink.h>
34 #include <linux/mount.h>
35 #include <linux/pagemap.h>
36 #include <linux/key.h>
37 #include <linux/parser.h>
38 #include <linux/fs_stack.h>
39 #include "ecryptfs_kernel.h"
40
41 /**
42 * Module parameter that defines the ecryptfs_
43 */
44 int ecryptfs_verbosity = 0;
45
46 module_param(ecryptfs_verbosity, int, 0);
47 MODULE_PARM_DESC(ecryptfs_verbosity,
48 "Initial verbosity level (0 o
49 "0, which is Quiet)");
50
51 /**
52 * Module parameter that defines the number of
53 * elements
54 */
55 unsigned int ecryptfs_message_buf_len = ECRYPT
56
57 module_param(ecryptfs_message_buf_len, uint, 0
58 MODULE_PARM_DESC(ecryptfs_message_buf_len,
59 "Number of message buffer ele
60
61 /**
62 * Module parameter that defines the maximum g
63 * for a response through netlink. The actual
64 * likely, a small amount greater than this sp
65 * the netlink message successfully arrives.
66 */
67 signed long ecryptfs_message_wait_timeout = EC
68
69 module_param(ecryptfs_message_wait_timeout, lo
70 MODULE_PARM_DESC(ecryptfs_message_wait_timeout
71 "Maximum number of seconds th
72 "sleep while waiting for a me
73 "userspace");
74
75 /**
76 * Module parameter that is an estimate of the
77 * that will be concurrently using eCryptfs. S
78 * value to balance performance and memory use
79 */
80 unsigned int ecryptfs_number_of_users = ECRYPT
81
82 module_param(ecryptfs_number_of_users, uint, 0
83 MODULE_PARM_DESC(ecryptfs_number_of_users, "An
84 "concurrent users of eCryptfs
85
86 unsigned int ecryptfs_transport = ECRYPTFS_DEF
87
88 void __ecryptfs_printk(const char *fmt, ...)
89 {
90 va_list args;
91 va_start(args, fmt);
92 if (fmt[1] == '7') { /* KERN_DEBUG */
93 if (ecryptfs_verbosity >= 1)
94 vprintk(fmt, args);
95 } else
96 vprintk(fmt, args);
97 va_end(args);
98 }
99
100 /**
101 * ecryptfs_init_persistent_file
102 * @ecryptfs_dentry: Fully initialized eCryptf
103 * the lower dentry and the
104 *
105 * eCryptfs only ever keeps a single open file
106 * inode. All I/O operations to the lower inod
107 * file. When the first eCryptfs dentry that i
108 * lower dentry for that inode is created, thi
109 * persistent file struct and associates it wi
110 * inode. When the eCryptfs inode is destroyed
111 *
112 * The persistent file will be opened with rea
113 * possible. Otherwise, it is opened read-only
114 *
115 * This function does nothing if a lower persi
116 * associated with the eCryptfs inode.
117 *
118 * Returns zero on success; non-zero otherwise
119 */
120 static int ecryptfs_init_persistent_file(struc
121 {
122 struct ecryptfs_inode_info *inode_info
123 ecryptfs_inode_to_private(ecry
124 int rc = 0;
125
126 mutex_lock(&inode_info->lower_file_mut
127 if (!inode_info->lower_file) {
128 struct dentry *lower_dentry;
129 struct vfsmount *lower_mnt =
130 ecryptfs_dentry_to_low
131
132 lower_dentry = ecryptfs_dentry
133 /* Corresponding dput() and mn
134 * persistent file is fput() w
135 * is destroyed. */
136 dget(lower_dentry);
137 mntget(lower_mnt);
138 inode_info->lower_file = dentr
139
140
141 if (IS_ERR(inode_info->lower_f
142 dget(lower_dentry);
143 mntget(lower_mnt);
144 inode_info->lower_file
145
146
147
148 }
149 if (IS_ERR(inode_info->lower_f
150 printk(KERN_ERR "Error
151 "for lower_dent
152 lower_dentry, l
153 rc = PTR_ERR(inode_inf
154 inode_info->lower_file
155 }
156 }
157 mutex_unlock(&inode_info->lower_file_m
158 return rc;
159 }
160
161 /**
162 * ecryptfs_interpose
163 * @lower_dentry: Existing dentry in the lower
164 * @dentry: ecryptfs' dentry
165 * @sb: ecryptfs's super_block
166 * @flag: If set to true, then d_add is called
167 *
168 * Interposes upper and lower dentries.
169 *
170 * Returns zero on success; non-zero otherwise
171 */
172 int ecryptfs_interpose(struct dentry *lower_de
173 struct super_block *sb,
174 {
175 struct inode *lower_inode;
176 struct inode *inode;
177 int rc = 0;
178
179 lower_inode = lower_dentry->d_inode;
180 if (lower_inode->i_sb != ecryptfs_supe
181 rc = -EXDEV;
182 goto out;
183 }
184 if (!igrab(lower_inode)) {
185 rc = -ESTALE;
186 goto out;
187 }
188 inode = iget5_locked(sb, (unsigned lon
189 ecryptfs_inode_te
190 lower_inode);
191 if (!inode) {
192 rc = -EACCES;
193 iput(lower_inode);
194 goto out;
195 }
196 if (inode->i_state & I_NEW)
197 unlock_new_inode(inode);
198 else
199 iput(lower_inode);
200 if (S_ISLNK(lower_inode->i_mode))
201 inode->i_op = &ecryptfs_symlin
202 else if (S_ISDIR(lower_inode->i_mode))
203 inode->i_op = &ecryptfs_dir_io
204 if (S_ISDIR(lower_inode->i_mode))
205 inode->i_fop = &ecryptfs_dir_f
206 if (special_file(lower_inode->i_mode))
207 init_special_inode(inode, lowe
208 lower_inode
209 dentry->d_op = &ecryptfs_dops;
210 if (flag)
211 d_add(dentry, inode);
212 else
213 d_instantiate(dentry, inode);
214 fsstack_copy_attr_all(inode, lower_ino
215 /* This size will be overwritten for r
216 * other metadata */
217 fsstack_copy_inode_size(inode, lower_i
218 rc = ecryptfs_init_persistent_file(den
219 if (rc) {
220 printk(KERN_ERR "%s: Error att
221 "persistent file for th
222 "rc = [%d]\n", __FUNCTI
223 goto out;
224 }
225 out:
226 return rc;
227 }
228
229 enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs
230 ecryptfs_opt_cipher, ecryptfs_opt_ecryp
231 ecryptfs_opt_ecryptfs_key_bytes,
232 ecryptfs_opt_passthrough, ecryptfs_opt_
233 ecryptfs_opt_encrypted_view, ecryptfs_o
234
235 static match_table_t tokens = {
236 {ecryptfs_opt_sig, "sig=%s"},
237 {ecryptfs_opt_ecryptfs_sig, "ecryptfs_
238 {ecryptfs_opt_cipher, "cipher=%s"},
239 {ecryptfs_opt_ecryptfs_cipher, "ecrypt
240 {ecryptfs_opt_ecryptfs_key_bytes, "ecr
241 {ecryptfs_opt_passthrough, "ecryptfs_p
242 {ecryptfs_opt_xattr_metadata, "ecryptf
243 {ecryptfs_opt_encrypted_view, "ecryptf
244 {ecryptfs_opt_err, NULL}
245 };
246
247 static int ecryptfs_init_global_auth_toks(
248 struct ecryptfs_mount_crypt_stat *moun
249 {
250 struct ecryptfs_global_auth_tok *globa
251 int rc = 0;
252
253 list_for_each_entry(global_auth_tok,
254 &mount_crypt_stat-
255 mount_crypt_stat_l
256 rc = ecryptfs_keyring_auth_tok
257 &global_auth_tok->glob
258 &global_auth_tok->glob
259 global_auth_tok->sig);
260 if (rc) {
261 printk(KERN_ERR "Could
262 "session keyrin
263 "option: [%s]\n
264 global_auth_tok->flags
265 rc = 0;
266 } else
267 global_auth_tok->flags
268 }
269 return rc;
270 }
271
272 static void ecryptfs_init_mount_crypt_stat(
273 struct ecryptfs_mount_crypt_stat *moun
274 {
275 memset((void *)mount_crypt_stat, 0,
276 sizeof(struct ecryptfs_mount_cr
277 INIT_LIST_HEAD(&mount_crypt_stat->glob
278 mutex_init(&mount_crypt_stat->global_a
279 mount_crypt_stat->flags |= ECRYPTFS_MO
280 }
281
282 /**
283 * ecryptfs_parse_options
284 * @sb: The ecryptfs super block
285 * @options: The options pased to the kernel
286 *
287 * Parse mount options:
288 * debug=N - ecryptfs_verbosity level
289 * sig=XXX - description(signature) of
290 *
291 * Returns the dentry object of the lower-leve
292 * directory; We want to mount our stackable f
293 * that lower directory.
294 *
295 * The signature of the key to use must be the
296 * already in the keyring. Mounting will fail
297 * found.
298 *
299 * Returns zero on success; non-zero on error
300 */
301 static int ecryptfs_parse_options(struct super
302 {
303 char *p;
304 int rc = 0;
305 int sig_set = 0;
306 int cipher_name_set = 0;
307 int cipher_key_bytes;
308 int cipher_key_bytes_set = 0;
309 struct ecryptfs_mount_crypt_stat *moun
310 &ecryptfs_superblock_to_privat
311 substring_t args[MAX_OPT_ARGS];
312 int token;
313 char *sig_src;
314 char *cipher_name_dst;
315 char *cipher_name_src;
316 char *cipher_key_bytes_src;
317 int cipher_name_len;
318
319 if (!options) {
320 rc = -EINVAL;
321 goto out;
322 }
323 ecryptfs_init_mount_crypt_stat(mount_c
324 while ((p = strsep(&options, ",")) !=
325 if (!*p)
326 continue;
327 token = match_token(p, tokens,
328 switch (token) {
329 case ecryptfs_opt_sig:
330 case ecryptfs_opt_ecryptfs_sig
331 sig_src = args[0].from
332 rc = ecryptfs_add_glob
333
334 if (rc) {
335 printk(KERN_ER
336 "global
337 goto out;
338 }
339 sig_set = 1;
340 break;
341 case ecryptfs_opt_cipher:
342 case ecryptfs_opt_ecryptfs_cip
343 cipher_name_src = args
344 cipher_name_dst =
345 mount_crypt_st
346 global_default
347 strncpy(cipher_name_ds
348 ECRYPTFS_MAX_C
349 ecryptfs_printk(KERN_D
350 "The m
351 "globa
352 "[%s]\
353 cipher_name_set = 1;
354 break;
355 case ecryptfs_opt_ecryptfs_key
356 cipher_key_bytes_src =
357 cipher_key_bytes =
358 (int)simple_st
359
360 mount_crypt_stat->glob
361 cipher_key_byt
362 ecryptfs_printk(KERN_D
363 "The m
364 "globa
365 "set t
366 global
367 cipher_key_bytes_set =
368 break;
369 case ecryptfs_opt_passthrough:
370 mount_crypt_stat->flag
371 ECRYPTFS_PLAIN
372 break;
373 case ecryptfs_opt_xattr_metada
374 mount_crypt_stat->flag
375 ECRYPTFS_XATTR
376 break;
377 case ecryptfs_opt_encrypted_vi
378 mount_crypt_stat->flag
379 ECRYPTFS_XATTR
380 mount_crypt_stat->flag
381 ECRYPTFS_ENCRY
382 break;
383 case ecryptfs_opt_err:
384 default:
385 ecryptfs_printk(KERN_W
386 "eCryp
387 p);
388 }
389 }
390 if (!sig_set) {
391 rc = -EINVAL;
392 ecryptfs_printk(KERN_ERR, "You
393 "auth tok sign
394 "parameter; se
395 goto out;
396 }
397 if (!cipher_name_set) {
398 cipher_name_len = strlen(ECRYP
399 if (unlikely(cipher_name_len
400 >= ECRYPTFS_MAX_C
401 rc = -EINVAL;
402 BUG();
403 goto out;
404 }
405 memcpy(mount_crypt_stat->globa
406 ECRYPTFS_DEFAULT_CIPHER
407 mount_crypt_stat->global_defau
408 = '\0';
409 }
410 if (!cipher_key_bytes_set) {
411 mount_crypt_stat->global_defau
412 }
413 mutex_lock(&key_tfm_list_mutex);
414 if (!ecryptfs_tfm_exists(mount_crypt_s
415 NULL))
416 rc = ecryptfs_add_new_key_tfm(
417 NULL, mount_crypt_stat
418 mount_crypt_stat->glob
419 mutex_unlock(&key_tfm_list_mutex);
420 if (rc) {
421 printk(KERN_ERR "Error attempt
422 "name = [%s] and key si
423 mount_crypt_stat->globa
424 mount_crypt_stat->globa
425 rc = -EINVAL;
426 goto out;
427 }
428 rc = ecryptfs_init_global_auth_toks(mo
429 if (rc) {
430 printk(KERN_WARNING "One or mo
431 "properly register; rc
432 }
433 rc = 0;
434 out:
435 return rc;
436 }
437
438 struct kmem_cache *ecryptfs_sb_info_cache;
439
440 /**
441 * ecryptfs_fill_super
442 * @sb: The ecryptfs super block
443 * @raw_data: The options passed to mount
444 * @silent: Not used but required by function
445 *
446 * Sets up what we can of the sb, rest is done
447 *
448 * Returns zero on success; non-zero otherwise
449 */
450 static int
451 ecryptfs_fill_super(struct super_block *sb, vo
452 {
453 int rc = 0;
454
455 /* Released in ecryptfs_put_super() */
456 ecryptfs_set_superblock_private(sb,
457 kmem_c
458
459 if (!ecryptfs_superblock_to_private(sb
460 ecryptfs_printk(KERN_WARNING,
461 rc = -ENOMEM;
462 goto out;
463 }
464 sb->s_op = &ecryptfs_sops;
465 /* Released through deactivate_super(s
466 sb->s_root = d_alloc(NULL, &(const str
467 .hash = 0,.name =
468 if (!sb->s_root) {
469 ecryptfs_printk(KERN_ERR, "d_a
470 rc = -ENOMEM;
471 goto out;
472 }
473 sb->s_root->d_op = &ecryptfs_dops;
474 sb->s_root->d_sb = sb;
475 sb->s_root->d_parent = sb->s_root;
476 /* Released in d_release when dput(sb-
477 /* through deactivate_super(sb) from g
478 ecryptfs_set_dentry_private(sb->s_root
479 kmem_cache
480
481 if (!ecryptfs_dentry_to_private(sb->s_
482 ecryptfs_printk(KERN_ERR,
483 "dentry_info_c
484 rc = -ENOMEM;
485 goto out;
486 }
487 rc = 0;
488 out:
489 /* Should be able to rely on deactivat
490 * get_sb_nodev */
491 return rc;
492 }
493
494 /**
495 * ecryptfs_read_super
496 * @sb: The ecryptfs super block
497 * @dev_name: The path to mount over
498 *
499 * Read the super block of the lower filesyste
500 * ecryptfs_interpose to create our initial in
501 * struct.
502 */
503 static int ecryptfs_read_super(struct super_bl
504 {
505 int rc;
506 struct nameidata nd;
507 struct dentry *lower_root;
508 struct vfsmount *lower_mnt;
509
510 memset(&nd, 0, sizeof(struct nameidata
511 rc = path_lookup(dev_name, LOOKUP_FOLL
512 if (rc) {
513 ecryptfs_printk(KERN_WARNING,
514 goto out;
515 }
516 lower_root = nd.path.dentry;
517 lower_mnt = nd.path.mnt;
518 ecryptfs_set_superblock_lower(sb, lowe
519 sb->s_maxbytes = lower_root->d_sb->s_m
520 sb->s_blocksize = lower_root->d_sb->s_
521 ecryptfs_set_dentry_lower(sb->s_root,
522 ecryptfs_set_dentry_lower_mnt(sb->s_ro
523 rc = ecryptfs_interpose(lower_root, sb
524 if (rc)
525 goto out_free;
526 rc = 0;
527 goto out;
528 out_free:
529 path_put(&nd.path);
530 out:
531 return rc;
532 }
533
534 /**
535 * ecryptfs_get_sb
536 * @fs_type
537 * @flags
538 * @dev_name: The path to mount over
539 * @raw_data: The options passed into the kern
540 *
541 * The whole ecryptfs_get_sb process is broken
542 * ecryptfs_parse_options(): handle options pa
543 * ecryptfs_fill_super(): used by get_sb_nodev
544 * with as much informa
545 * the lower filesystem
546 * ecryptfs_read_super(): this accesses the lo
547 * ecryptfs_interpolate
548 * ecryptfs_interpolate(): links the lower fil
549 */
550 static int ecryptfs_get_sb(struct file_system_
551 const char *dev_name,
552 struct vfsmount *mnt)
553 {
554 int rc;
555 struct super_block *sb;
556
557 rc = get_sb_nodev(fs_type, flags, raw_
558 if (rc < 0) {
559 printk(KERN_ERR "Getting sb fa
560 goto out;
561 }
562 sb = mnt->mnt_sb;
563 rc = ecryptfs_parse_options(sb, raw_da
564 if (rc) {
565 printk(KERN_ERR "Error parsing
566 goto out_abort;
567 }
568 rc = ecryptfs_read_super(sb, dev_name)
569 if (rc) {
570 printk(KERN_ERR "Reading sb fa
571 goto out_abort;
572 }
573 goto out;
574 out_abort:
575 dput(sb->s_root);
576 up_write(&sb->s_umount);
577 deactivate_super(sb);
578 out:
579 return rc;
580 }
581
582 /**
583 * ecryptfs_kill_block_super
584 * @sb: The ecryptfs super block
585 *
586 * Used to bring the superblock down and free
587 * Private data is free'd in ecryptfs_put_supe
588 */
589 static void ecryptfs_kill_block_super(struct s
590 {
591 generic_shutdown_super(sb);
592 }
593
594 static struct file_system_type ecryptfs_fs_typ
595 .owner = THIS_MODULE,
596 .name = "ecryptfs",
597 .get_sb = ecryptfs_get_sb,
598 .kill_sb = ecryptfs_kill_block_super,
599 .fs_flags = 0
600 };
601
602 /**
603 * inode_info_init_once
604 *
605 * Initializes the ecryptfs_inode_info_cache w
606 */
607 static void
608 inode_info_init_once(struct kmem_cache *cachep
609 {
610 struct ecryptfs_inode_info *ei = (stru
611
612 inode_init_once(&ei->vfs_inode);
613 }
614
615 static struct ecryptfs_cache_info {
616 struct kmem_cache **cache;
617 const char *name;
618 size_t size;
619 void (*ctor)(struct kmem_cache *cache,
620 } ecryptfs_cache_infos[] = {
621 {
622 .cache = &ecryptfs_auth_tok_li
623 .name = "ecryptfs_auth_tok_lis
624 .size = sizeof(struct ecryptfs
625 },
626 {
627 .cache = &ecryptfs_file_info_c
628 .name = "ecryptfs_file_cache",
629 .size = sizeof(struct ecryptfs
630 },
631 {
632 .cache = &ecryptfs_dentry_info
633 .name = "ecryptfs_dentry_info_
634 .size = sizeof(struct ecryptfs
635 },
636 {
637 .cache = &ecryptfs_inode_info_
638 .name = "ecryptfs_inode_cache"
639 .size = sizeof(struct ecryptfs
640 .ctor = inode_info_init_once,
641 },
642 {
643 .cache = &ecryptfs_sb_info_cac
644 .name = "ecryptfs_sb_cache",
645 .size = sizeof(struct ecryptfs
646 },
647 {
648 .cache = &ecryptfs_header_cach
649 .name = "ecryptfs_headers_1",
650 .size = PAGE_CACHE_SIZE,
651 },
652 {
653 .cache = &ecryptfs_header_cach
654 .name = "ecryptfs_headers_2",
655 .size = PAGE_CACHE_SIZE,
656 },
657 {
658 .cache = &ecryptfs_xattr_cache
659 .name = "ecryptfs_xattr_cache"
660 .size = PAGE_CACHE_SIZE,
661 },
662 {
663 .cache = &ecryptfs_key_record_
664 .name = "ecryptfs_key_record_c
665 .size = sizeof(struct ecryptfs
666 },
667 {
668 .cache = &ecryptfs_key_sig_cac
669 .name = "ecryptfs_key_sig_cach
670 .size = sizeof(struct ecryptfs
671 },
672 {
673 .cache = &ecryptfs_global_auth
674 .name = "ecryptfs_global_auth_
675 .size = sizeof(struct ecryptfs
676 },
677 {
678 .cache = &ecryptfs_key_tfm_cac
679 .name = "ecryptfs_key_tfm_cach
680 .size = sizeof(struct ecryptfs
681 },
682 };
683
684 static void ecryptfs_free_kmem_caches(void)
685 {
686 int i;
687
688 for (i = 0; i < ARRAY_SIZE(ecryptfs_ca
689 struct ecryptfs_cache_info *in
690
691 info = &ecryptfs_cache_infos[i
692 if (*(info->cache))
693 kmem_cache_destroy(*(i
694 }
695 }
696
697 /**
698 * ecryptfs_init_kmem_caches
699 *
700 * Returns zero on success; non-zero otherwise
701 */
702 static int ecryptfs_init_kmem_caches(void)
703 {
704 int i;
705
706 for (i = 0; i < ARRAY_SIZE(ecryptfs_ca
707 struct ecryptfs_cache_info *in
708
709 info = &ecryptfs_cache_infos[i
710 *(info->cache) = kmem_cache_cr
711 0, SLAB_HWCACH
712 if (!*(info->cache)) {
713 ecryptfs_free_kmem_cac
714 ecryptfs_printk(KERN_W
715 "kmem_
716 info->
717 return -ENOMEM;
718 }
719 }
720 return 0;
721 }
722
723 static struct kobject *ecryptfs_kobj;
724
725 static ssize_t version_show(struct kobject *ko
726 struct kobj_attrib
727 {
728 return snprintf(buff, PAGE_SIZE, "%d\n
729 }
730
731 static struct kobj_attribute version_attr = __
732
733 static struct attribute *attributes[] = {
734 &version_attr.attr,
735 NULL,
736 };
737
738 static struct attribute_group attr_group = {
739 .attrs = attributes,
740 };
741
742 static int do_sysfs_registration(void)
743 {
744 int rc;
745
746 ecryptfs_kobj = kobject_create_and_add
747 if (!ecryptfs_kobj) {
748 printk(KERN_ERR "Unable to cre
749 rc = -ENOMEM;
750 goto out;
751 }
752 rc = sysfs_create_group(ecryptfs_kobj,
753 if (rc) {
754 printk(KERN_ERR
755 "Unable to create ecryp
756 kobject_put(ecryptfs_kobj);
757 }
758 out:
759 return rc;
760 }
761
762 static void do_sysfs_unregistration(void)
763 {
764 sysfs_remove_group(ecryptfs_kobj, &att
765 kobject_put(ecryptfs_kobj);
766 }
767
768 static int __init ecryptfs_init(void)
769 {
770 int rc;
771
772 if (ECRYPTFS_DEFAULT_EXTENT_SIZE > PAG
773 rc = -EINVAL;
774 ecryptfs_printk(KERN_ERR, "The
775 "larger than t
776 "eCryptfs cann
777 "default eCryp
778 "the page size
779 ECRYPTFS_DEFAU
780 goto out;
781 }
782 rc = ecryptfs_init_kmem_caches();
783 if (rc) {
784 printk(KERN_ERR
785 "Failed to allocate one
786 goto out;
787 }
788 rc = register_filesystem(&ecryptfs_fs_
789 if (rc) {
790 printk(KERN_ERR "Failed to reg
791 goto out_free_kmem_caches;
792 }
793 rc = do_sysfs_registration();
794 if (rc) {
795 printk(KERN_ERR "sysfs registr
796 goto out_unregister_filesystem
797 }
798 rc = ecryptfs_init_messaging(ecryptfs_
799 if (rc) {
800 ecryptfs_printk(KERN_ERR, "Fai
801 "initialize th
802 goto out_do_sysfs_unregistrati
803 }
804 rc = ecryptfs_init_crypto();
805 if (rc) {
806 printk(KERN_ERR "Failure whils
807 "rc = [%d]\n", rc);
808 goto out_release_messaging;
809 }
810 if (ecryptfs_verbosity > 0)
811 printk(KERN_CRIT "eCryptfs ver
812 "will be written to th
813
814 goto out;
815 out_release_messaging:
816 ecryptfs_release_messaging(ecryptfs_tr
817 out_do_sysfs_unregistration:
818 do_sysfs_unregistration();
819 out_unregister_filesystem:
820 unregister_filesystem(&ecryptfs_fs_typ
821 out_free_kmem_caches:
822 ecryptfs_free_kmem_caches();
823 out:
824 return rc;
825 }
826
827 static void __exit ecryptfs_exit(void)
828 {
829 int rc;
830
831 rc = ecryptfs_destroy_crypto();
832 if (rc)
833 printk(KERN_ERR "Failure whils
834 "rc = [%d]\n", rc);
835 ecryptfs_release_messaging(ecryptfs_tr
836 do_sysfs_unregistration();
837 unregister_filesystem(&ecryptfs_fs_typ
838 ecryptfs_free_kmem_caches();
839 }
840
841 MODULE_AUTHOR("Michael A. Halcrow <mhalcrow@us
842 MODULE_DESCRIPTION("eCryptfs");
843
844 MODULE_LICENSE("GPL");
845
846 module_init(ecryptfs_init)
847 module_exit(ecryptfs_exit)
848
| This page was automatically generated by the LXR engine. |