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/dcache.h> 27 #include <linux/file.h> 28 #include <linux/module.h> 29 #include <linux/namei.h> 30 #include <linux/skbuff.h> 31 #include <linux/crypto.h> 32 #include <linux/netlink.h> 33 #include <linux/mount.h> 34 #include <linux/dcache.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_verbosity level. 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 or 1; defaults to " 49 "0, which is Quiet)"); 50 51 void __ecryptfs_printk(const char *fmt, ...) 52 { 53 va_list args; 54 va_start(args, fmt); 55 if (fmt[1] == '7') { /* KERN_DEBUG */ 56 if (ecryptfs_verbosity >= 1) 57 vprintk(fmt, args); 58 } else 59 vprintk(fmt, args); 60 va_end(args); 61 } 62 63 /** 64 * ecryptfs_interpose 65 * @lower_dentry: Existing dentry in the lower filesystem 66 * @dentry: ecryptfs' dentry 67 * @sb: ecryptfs's super_block 68 * @flag: If set to true, then d_add is called, else d_instantiate is called 69 * 70 * Interposes upper and lower dentries. 71 * 72 * Returns zero on success; non-zero otherwise 73 */ 74 int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry, 75 struct super_block *sb, int flag) 76 { 77 struct inode *lower_inode; 78 struct inode *inode; 79 int rc = 0; 80 81 lower_inode = lower_dentry->d_inode; 82 if (lower_inode->i_sb != ecryptfs_superblock_to_lower(sb)) { 83 rc = -EXDEV; 84 goto out; 85 } 86 if (!igrab(lower_inode)) { 87 rc = -ESTALE; 88 goto out; 89 } 90 inode = iget5_locked(sb, (unsigned long)lower_inode, 91 ecryptfs_inode_test, ecryptfs_inode_set, 92 lower_inode); 93 if (!inode) { 94 rc = -EACCES; 95 iput(lower_inode); 96 goto out; 97 } 98 if (inode->i_state & I_NEW) 99 unlock_new_inode(inode); 100 else 101 iput(lower_inode); 102 if (S_ISLNK(lower_inode->i_mode)) 103 inode->i_op = &ecryptfs_symlink_iops; 104 else if (S_ISDIR(lower_inode->i_mode)) 105 inode->i_op = &ecryptfs_dir_iops; 106 if (S_ISDIR(lower_inode->i_mode)) 107 inode->i_fop = &ecryptfs_dir_fops; 108 if (special_file(lower_inode->i_mode)) 109 init_special_inode(inode, lower_inode->i_mode, 110 lower_inode->i_rdev); 111 dentry->d_op = &ecryptfs_dops; 112 if (flag) 113 d_add(dentry, inode); 114 else 115 d_instantiate(dentry, inode); 116 fsstack_copy_attr_all(inode, lower_inode, NULL); 117 /* This size will be overwritten for real files w/ headers and 118 * other metadata */ 119 fsstack_copy_inode_size(inode, lower_inode); 120 out: 121 return rc; 122 } 123 124 enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig, ecryptfs_opt_debug, 125 ecryptfs_opt_ecryptfs_debug, ecryptfs_opt_cipher, 126 ecryptfs_opt_ecryptfs_cipher, ecryptfs_opt_ecryptfs_key_bytes, 127 ecryptfs_opt_passthrough, ecryptfs_opt_err }; 128 129 static match_table_t tokens = { 130 {ecryptfs_opt_sig, "sig=%s"}, 131 {ecryptfs_opt_ecryptfs_sig, "ecryptfs_sig=%s"}, 132 {ecryptfs_opt_debug, "debug=%u"}, 133 {ecryptfs_opt_ecryptfs_debug, "ecryptfs_debug=%u"}, 134 {ecryptfs_opt_cipher, "cipher=%s"}, 135 {ecryptfs_opt_ecryptfs_cipher, "ecryptfs_cipher=%s"}, 136 {ecryptfs_opt_ecryptfs_key_bytes, "ecryptfs_key_bytes=%u"}, 137 {ecryptfs_opt_passthrough, "ecryptfs_passthrough"}, 138 {ecryptfs_opt_err, NULL} 139 }; 140 141 /** 142 * ecryptfs_verify_version 143 * @version: The version number to confirm 144 * 145 * Returns zero on good version; non-zero otherwise 146 */ 147 static int ecryptfs_verify_version(u16 version) 148 { 149 int rc = 0; 150 unsigned char major; 151 unsigned char minor; 152 153 major = ((version >> 8) & 0xFF); 154 minor = (version & 0xFF); 155 if (major != ECRYPTFS_VERSION_MAJOR) { 156 ecryptfs_printk(KERN_ERR, "Major version number mismatch. " 157 "Expected [%d]; got [%d]\n", 158 ECRYPTFS_VERSION_MAJOR, major); 159 rc = -EINVAL; 160 goto out; 161 } 162 if (minor != ECRYPTFS_VERSION_MINOR) { 163 ecryptfs_printk(KERN_ERR, "Minor version number mismatch. " 164 "Expected [%d]; got [%d]\n", 165 ECRYPTFS_VERSION_MINOR, minor); 166 rc = -EINVAL; 167 goto out; 168 } 169 out: 170 return rc; 171 } 172 173 /** 174 * ecryptfs_parse_options 175 * @sb: The ecryptfs super block 176 * @options: The options pased to the kernel 177 * 178 * Parse mount options: 179 * debug=N - ecryptfs_verbosity level for debug output 180 * sig=XXX - description(signature) of the key to use 181 * 182 * Returns the dentry object of the lower-level (lower/interposed) 183 * directory; We want to mount our stackable file system on top of 184 * that lower directory. 185 * 186 * The signature of the key to use must be the description of a key 187 * already in the keyring. Mounting will fail if the key can not be 188 * found. 189 * 190 * Returns zero on success; non-zero on error 191 */ 192 static int ecryptfs_parse_options(struct super_block *sb, char *options) 193 { 194 char *p; 195 int rc = 0; 196 int sig_set = 0; 197 int cipher_name_set = 0; 198 int cipher_key_bytes; 199 int cipher_key_bytes_set = 0; 200 struct key *auth_tok_key = NULL; 201 struct ecryptfs_auth_tok *auth_tok = NULL; 202 struct ecryptfs_mount_crypt_stat *mount_crypt_stat = 203 &ecryptfs_superblock_to_private(sb)->mount_crypt_stat; 204 substring_t args[MAX_OPT_ARGS]; 205 int token; 206 char *sig_src; 207 char *sig_dst; 208 char *debug_src; 209 char *cipher_name_dst; 210 char *cipher_name_src; 211 char *cipher_key_bytes_src; 212 int cipher_name_len; 213 214 if (!options) { 215 rc = -EINVAL; 216 goto out; 217 } 218 while ((p = strsep(&options, ",")) != NULL) { 219 if (!*p) 220 continue; 221 token = match_token(p, tokens, args); 222 switch (token) { 223 case ecryptfs_opt_sig: 224 case ecryptfs_opt_ecryptfs_sig: 225 sig_src = args[0].from; 226 sig_dst = 227 mount_crypt_stat->global_auth_tok_sig; 228 memcpy(sig_dst, sig_src, ECRYPTFS_SIG_SIZE_HEX); 229 sig_dst[ECRYPTFS_SIG_SIZE_HEX] = '\0'; 230 ecryptfs_printk(KERN_DEBUG, 231 "The mount_crypt_stat " 232 "global_auth_tok_sig set to: " 233 "[%s]\n", sig_dst); 234 sig_set = 1; 235 break; 236 case ecryptfs_opt_debug: 237 case ecryptfs_opt_ecryptfs_debug: 238 debug_src = args[0].from; 239 ecryptfs_verbosity = 240 (int)simple_strtol(debug_src, &debug_src, 241 0); 242 ecryptfs_printk(KERN_DEBUG, 243 "Verbosity set to [%d]" "\n", 244 ecryptfs_verbosity); 245 break; 246 case ecryptfs_opt_cipher: 247 case ecryptfs_opt_ecryptfs_cipher: 248 cipher_name_src = args[0].from; 249 cipher_name_dst = 250 mount_crypt_stat-> 251 global_default_cipher_name; 252 strncpy(cipher_name_dst, cipher_name_src, 253 ECRYPTFS_MAX_CIPHER_NAME_SIZE); 254 ecryptfs_printk(KERN_DEBUG, 255 "The mount_crypt_stat " 256 "global_default_cipher_name set to: " 257 "[%s]\n", cipher_name_dst); 258 cipher_name_set = 1; 259 break; 260 case ecryptfs_opt_ecryptfs_key_bytes: 261 cipher_key_bytes_src = args[0].from; 262 cipher_key_bytes = 263 (int)simple_strtol(cipher_key_bytes_src, 264 &cipher_key_bytes_src, 0); 265 mount_crypt_stat->global_default_cipher_key_size = 266 cipher_key_bytes; 267 ecryptfs_printk(KERN_DEBUG, 268 "The mount_crypt_stat " 269 "global_default_cipher_key_size " 270 "set to: [%d]\n", mount_crypt_stat-> 271 global_default_cipher_key_size); 272 cipher_key_bytes_set = 1; 273 break; 274 case ecryptfs_opt_passthrough: 275 mount_crypt_stat->flags |= 276 ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED; 277 break; 278 case ecryptfs_opt_err: 279 default: 280 ecryptfs_printk(KERN_WARNING, 281 "eCryptfs: unrecognized option '%s'\n", 282 p); 283 } 284 } 285 /* Do not support lack of mount-wide signature in 0.1 286 * release */ 287 if (!sig_set) { 288 rc = -EINVAL; 289 ecryptfs_printk(KERN_ERR, "You must supply a valid " 290 "passphrase auth tok signature as a mount " 291 "parameter; see the eCryptfs README\n"); 292 goto out; 293 } 294 if (!cipher_name_set) { 295 cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER); 296 if (unlikely(cipher_name_len 297 >= ECRYPTFS_MAX_CIPHER_NAME_SIZE)) { 298 rc = -EINVAL; 299 BUG(); 300 goto out; 301 } 302 memcpy(mount_crypt_stat->global_default_cipher_name, 303 ECRYPTFS_DEFAULT_CIPHER, cipher_name_len); 304 mount_crypt_stat->global_default_cipher_name[cipher_name_len] 305 = '\0'; 306 } 307 if (!cipher_key_bytes_set) { 308 mount_crypt_stat->global_default_cipher_key_size = 0; 309 } 310 rc = ecryptfs_process_cipher( 311 &mount_crypt_stat->global_key_tfm, 312 mount_crypt_stat->global_default_cipher_name, 313 &mount_crypt_stat->global_default_cipher_key_size); 314 if (rc) { 315 printk(KERN_ERR "Error attempting to initialize cipher [%s] " 316 "with key size [%Zd] bytes; rc = [%d]\n", 317 mount_crypt_stat->global_default_cipher_name, 318 mount_crypt_stat->global_default_cipher_key_size, rc); 319 mount_crypt_stat->global_key_tfm = NULL; 320 mount_crypt_stat->global_auth_tok_key = NULL; 321 rc = -EINVAL; 322 goto out; 323 } 324 mutex_init(&mount_crypt_stat->global_key_tfm_mutex); 325 ecryptfs_printk(KERN_DEBUG, "Requesting the key with description: " 326 "[%s]\n", mount_crypt_stat->global_auth_tok_sig); 327 /* The reference to this key is held until umount is done The 328 * call to key_put is done in ecryptfs_put_super() */ 329 auth_tok_key = request_key(&key_type_user, 330 mount_crypt_stat->global_auth_tok_sig, 331 NULL); 332 if (!auth_tok_key || IS_ERR(auth_tok_key)) { 333 ecryptfs_printk(KERN_ERR, "Could not find key with " 334 "description: [%s]\n", 335 mount_crypt_stat->global_auth_tok_sig); 336 process_request_key_err(PTR_ERR(auth_tok_key)); 337 rc = -EINVAL; 338 goto out; 339 } 340 auth_tok = ecryptfs_get_key_payload_data(auth_tok_key); 341 if (ecryptfs_verify_version(auth_tok->version)) { 342 ecryptfs_printk(KERN_ERR, "Data structure version mismatch. " 343 "Userspace tools must match eCryptfs kernel " 344 "module with major version [%d] and minor " 345 "version [%d]\n", ECRYPTFS_VERSION_MAJOR, 346 ECRYPTFS_VERSION_MINOR); 347 rc = -EINVAL; 348 goto out; 349 } 350 if (auth_tok->token_type != ECRYPTFS_PASSWORD) { 351 ecryptfs_printk(KERN_ERR, "Invalid auth_tok structure " 352 "returned from key\n"); 353 rc = -EINVAL; 354 goto out; 355 } 356 mount_crypt_stat->global_auth_tok_key = auth_tok_key; 357 mount_crypt_stat->global_auth_tok = auth_tok; 358 out: 359 return rc; 360 } 361 362 struct kmem_cache *ecryptfs_sb_info_cache; 363 364 /** 365 * ecryptfs_fill_super 366 * @sb: The ecryptfs super block 367 * @raw_data: The options passed to mount 368 * @silent: Not used but required by function prototype 369 * 370 * Sets up what we can of the sb, rest is done in ecryptfs_read_super 371 * 372 * Returns zero on success; non-zero otherwise 373 */ 374 static int 375 ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent) 376 { 377 int rc = 0; 378 379 /* Released in ecryptfs_put_super() */ 380 ecryptfs_set_superblock_private(sb, 381 kmem_cache_alloc(ecryptfs_sb_info_cache, 382 GFP_KERNEL)); 383 if (!ecryptfs_superblock_to_private(sb)) { 384 ecryptfs_printk(KERN_WARNING, "Out of memory\n"); 385 rc = -ENOMEM; 386 goto out; 387 } 388 memset(ecryptfs_superblock_to_private(sb), 0, 389 sizeof(struct ecryptfs_sb_info)); 390 sb->s_op = &ecryptfs_sops; 391 /* Released through deactivate_super(sb) from get_sb_nodev */ 392 sb->s_root = d_alloc(NULL, &(const struct qstr) { 393 .hash = 0,.name = "/",.len = 1}); 394 if (!sb->s_root) { 395 ecryptfs_printk(KERN_ERR, "d_alloc failed\n"); 396 rc = -ENOMEM; 397 goto out; 398 } 399 sb->s_root->d_op = &ecryptfs_dops; 400 sb->s_root->d_sb = sb; 401 sb->s_root->d_parent = sb->s_root; 402 /* Released in d_release when dput(sb->s_root) is called */ 403 /* through deactivate_super(sb) from get_sb_nodev() */ 404 ecryptfs_set_dentry_private(sb->s_root, 405 kmem_cache_alloc(ecryptfs_dentry_info_cache, 406 GFP_KERNEL)); 407 if (!ecryptfs_dentry_to_private(sb->s_root)) { 408 ecryptfs_printk(KERN_ERR, 409 "dentry_info_cache alloc failed\n"); 410 rc = -ENOMEM; 411 goto out; 412 } 413 memset(ecryptfs_dentry_to_private(sb->s_root), 0, 414 sizeof(struct ecryptfs_dentry_info)); 415 rc = 0; 416 out: 417 /* Should be able to rely on deactivate_super called from 418 * get_sb_nodev */ 419 return rc; 420 } 421 422 /** 423 * ecryptfs_read_super 424 * @sb: The ecryptfs super block 425 * @dev_name: The path to mount over 426 * 427 * Read the super block of the lower filesystem, and use 428 * ecryptfs_interpose to create our initial inode and super block 429 * struct. 430 */ 431 static int ecryptfs_read_super(struct super_block *sb, const char *dev_name) 432 { 433 int rc; 434 struct nameidata nd; 435 struct dentry *lower_root; 436 struct vfsmount *lower_mnt; 437 438 memset(&nd, 0, sizeof(struct nameidata)); 439 rc = path_lookup(dev_name, LOOKUP_FOLLOW, &nd); 440 if (rc) { 441 ecryptfs_printk(KERN_WARNING, "path_lookup() failed\n"); 442 goto out_free; 443 } 444 lower_root = nd.dentry; 445 if (!lower_root->d_inode) { 446 ecryptfs_printk(KERN_WARNING, 447 "No directory to interpose on\n"); 448 rc = -ENOENT; 449 goto out_free; 450 } 451 lower_mnt = nd.mnt; 452 ecryptfs_set_superblock_lower(sb, lower_root->d_sb); 453 sb->s_maxbytes = lower_root->d_sb->s_maxbytes; 454 ecryptfs_set_dentry_lower(sb->s_root, lower_root); 455 ecryptfs_set_dentry_lower_mnt(sb->s_root, lower_mnt); 456 if ((rc = ecryptfs_interpose(lower_root, sb->s_root, sb, 0))) 457 goto out_free; 458 rc = 0; 459 goto out; 460 out_free: 461 path_release(&nd); 462 out: 463 return rc; 464 } 465 466 /** 467 * ecryptfs_get_sb 468 * @fs_type 469 * @flags 470 * @dev_name: The path to mount over 471 * @raw_data: The options passed into the kernel 472 * 473 * The whole ecryptfs_get_sb process is broken into 4 functions: 474 * ecryptfs_parse_options(): handle options passed to ecryptfs, if any 475 * ecryptfs_fill_super(): used by get_sb_nodev, fills out the super_block 476 * with as much information as it can before needing 477 * the lower filesystem. 478 * ecryptfs_read_super(): this accesses the lower filesystem and uses 479 * ecryptfs_interpolate to perform most of the linking 480 * ecryptfs_interpolate(): links the lower filesystem into ecryptfs 481 */ 482 static int ecryptfs_get_sb(struct file_system_type *fs_type, int flags, 483 const char *dev_name, void *raw_data, 484 struct vfsmount *mnt) 485 { 486 int rc; 487 struct super_block *sb; 488 489 rc = get_sb_nodev(fs_type, flags, raw_data, ecryptfs_fill_super, mnt); 490 if (rc < 0) { 491 printk(KERN_ERR "Getting sb failed; rc = [%d]\n", rc); 492 goto out; 493 } 494 sb = mnt->mnt_sb; 495 rc = ecryptfs_parse_options(sb, raw_data); 496 if (rc) { 497 printk(KERN_ERR "Error parsing options; rc = [%d]\n", rc); 498 goto out_abort; 499 } 500 rc = ecryptfs_read_super(sb, dev_name); 501 if (rc) { 502 printk(KERN_ERR "Reading sb failed; rc = [%d]\n", rc); 503 goto out_abort; 504 } 505 goto out; 506 out_abort: 507 dput(sb->s_root); 508 up_write(&sb->s_umount); 509 deactivate_super(sb); 510 out: 511 return rc; 512 } 513 514 /** 515 * ecryptfs_kill_block_super 516 * @sb: The ecryptfs super block 517 * 518 * Used to bring the superblock down and free the private data. 519 * Private data is free'd in ecryptfs_put_super() 520 */ 521 static void ecryptfs_kill_block_super(struct super_block *sb) 522 { 523 generic_shutdown_super(sb); 524 } 525 526 static struct file_system_type ecryptfs_fs_type = { 527 .owner = THIS_MODULE, 528 .name = "ecryptfs", 529 .get_sb = ecryptfs_get_sb, 530 .kill_sb = ecryptfs_kill_block_super, 531 .fs_flags = 0 532 }; 533 534 /** 535 * inode_info_init_once 536 * 537 * Initializes the ecryptfs_inode_info_cache when it is created 538 */ 539 static void 540 inode_info_init_once(void *vptr, struct kmem_cache *cachep, unsigned long flags) 541 { 542 struct ecryptfs_inode_info *ei = (struct ecryptfs_inode_info *)vptr; 543 544 if ((flags & (SLAB_CTOR_VERIFY | SLAB_CTOR_CONSTRUCTOR)) == 545 SLAB_CTOR_CONSTRUCTOR) 546 inode_init_once(&ei->vfs_inode); 547 } 548 549 static struct ecryptfs_cache_info { 550 struct kmem_cache **cache; 551 const char *name; 552 size_t size; 553 void (*ctor)(void*, struct kmem_cache *, unsigned long); 554 } ecryptfs_cache_infos[] = { 555 { 556 .cache = &ecryptfs_auth_tok_list_item_cache, 557 .name = "ecryptfs_auth_tok_list_item", 558 .size = sizeof(struct ecryptfs_auth_tok_list_item), 559 }, 560 { 561 .cache = &ecryptfs_file_info_cache, 562 .name = "ecryptfs_file_cache", 563 .size = sizeof(struct ecryptfs_file_info), 564 }, 565 { 566 .cache = &ecryptfs_dentry_info_cache, 567 .name = "ecryptfs_dentry_info_cache", 568 .size = sizeof(struct ecryptfs_dentry_info), 569 }, 570 { 571 .cache = &ecryptfs_inode_info_cache, 572 .name = "ecryptfs_inode_cache", 573 .size = sizeof(struct ecryptfs_inode_info), 574 .ctor = inode_info_init_once, 575 }, 576 { 577 .cache = &ecryptfs_sb_info_cache, 578 .name = "ecryptfs_sb_cache", 579 .size = sizeof(struct ecryptfs_sb_info), 580 }, 581 { 582 .cache = &ecryptfs_header_cache_0, 583 .name = "ecryptfs_headers_0", 584 .size = PAGE_CACHE_SIZE, 585 }, 586 { 587 .cache = &ecryptfs_header_cache_1, 588 .name = "ecryptfs_headers_1", 589 .size = PAGE_CACHE_SIZE, 590 }, 591 { 592 .cache = &ecryptfs_header_cache_2, 593 .name = "ecryptfs_headers_2", 594 .size = PAGE_CACHE_SIZE, 595 }, 596 { 597 .cache = &ecryptfs_lower_page_cache, 598 .name = "ecryptfs_lower_page_cache", 599 .size = PAGE_CACHE_SIZE, 600 }, 601 }; 602 603 static void ecryptfs_free_kmem_caches(void) 604 { 605 int i; 606 607 for (i = 0; i < ARRAY_SIZE(ecryptfs_cache_infos); i++) { 608 struct ecryptfs_cache_info *info; 609 610 info = &ecryptfs_cache_infos[i]; 611 if (*(info->cache)) 612 kmem_cache_destroy(*(info->cache)); 613 } 614 } 615 616 /** 617 * ecryptfs_init_kmem_caches 618 * 619 * Returns zero on success; non-zero otherwise 620 */ 621 static int ecryptfs_init_kmem_caches(void) 622 { 623 int i; 624 625 for (i = 0; i < ARRAY_SIZE(ecryptfs_cache_infos); i++) { 626 struct ecryptfs_cache_info *info; 627 628 info = &ecryptfs_cache_infos[i]; 629 *(info->cache) = kmem_cache_create(info->name, info->size, 630 0, SLAB_HWCACHE_ALIGN, info->ctor, NULL); 631 if (!*(info->cache)) { 632 ecryptfs_free_kmem_caches(); 633 ecryptfs_printk(KERN_WARNING, "%s: " 634 "kmem_cache_create failed\n", 635 info->name); 636 return -ENOMEM; 637 } 638 } 639 return 0; 640 } 641 642 struct ecryptfs_obj { 643 char *name; 644 struct list_head slot_list; 645 struct kobject kobj; 646 }; 647 648 struct ecryptfs_attribute { 649 struct attribute attr; 650 ssize_t(*show) (struct ecryptfs_obj *, char *); 651 ssize_t(*store) (struct ecryptfs_obj *, const char *, size_t); 652 }; 653 654 static ssize_t 655 ecryptfs_attr_store(struct kobject *kobj, 656 struct attribute *attr, const char *buf, size_t len) 657 { 658 struct ecryptfs_obj *obj = container_of(kobj, struct ecryptfs_obj, 659 kobj); 660 struct ecryptfs_attribute *attribute = 661 container_of(attr, struct ecryptfs_attribute, attr); 662 663 return (attribute->store ? attribute->store(obj, buf, len) : 0); 664 } 665 666 static ssize_t 667 ecryptfs_attr_show(struct kobject *kobj, struct attribute *attr, char *buf) 668 { 669 struct ecryptfs_obj *obj = container_of(kobj, struct ecryptfs_obj, 670 kobj); 671 struct ecryptfs_attribute *attribute = 672 container_of(attr, struct ecryptfs_attribute, attr); 673 674 return (attribute->show ? attribute->show(obj, buf) : 0); 675 } 676 677 static struct sysfs_ops ecryptfs_sysfs_ops = { 678 .show = ecryptfs_attr_show, 679 .store = ecryptfs_attr_store 680 }; 681 682 static struct kobj_type ecryptfs_ktype = { 683 .sysfs_ops = &ecryptfs_sysfs_ops 684 }; 685 686 static decl_subsys(ecryptfs, &ecryptfs_ktype, NULL); 687 688 static ssize_t version_show(struct ecryptfs_obj *obj, char *buff) 689 { 690 return snprintf(buff, PAGE_SIZE, "%d\n", ECRYPTFS_VERSIONING_MASK); 691 } 692 693 static struct ecryptfs_attribute sysfs_attr_version = __ATTR_RO(version); 694 695 static struct ecryptfs_version_str_map_elem { 696 u32 flag; 697 char *str; 698 } ecryptfs_version_str_map[] = { 699 {ECRYPTFS_VERSIONING_PASSPHRASE, "passphrase"}, 700 {ECRYPTFS_VERSIONING_PUBKEY, "pubkey"}, 701 {ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH, "plaintext passthrough"}, 702 {ECRYPTFS_VERSIONING_POLICY, "policy"} 703 }; 704 705 static ssize_t version_str_show(struct ecryptfs_obj *obj, char *buff) 706 { 707 int i; 708 int remaining = PAGE_SIZE; 709 int total_written = 0; 710 711 buff[0] = '\0'; 712 for (i = 0; i < ARRAY_SIZE(ecryptfs_version_str_map); i++) { 713 int entry_size; 714 715 if (!(ECRYPTFS_VERSIONING_MASK 716 & ecryptfs_version_str_map[i].flag)) 717 continue; 718 entry_size = strlen(ecryptfs_version_str_map[i].str); 719 if ((entry_size + 2) > remaining) 720 goto out; 721 memcpy(buff, ecryptfs_version_str_map[i].str, entry_size); 722 buff[entry_size++] = '\n'; 723 buff[entry_size] = '\0'; 724 buff += entry_size; 725 total_written += entry_size; 726 remaining -= entry_size; 727 } 728 out: 729 return total_written; 730 } 731 732 static struct ecryptfs_attribute sysfs_attr_version_str = __ATTR_RO(version_str); 733 734 static int do_sysfs_registration(void) 735 { 736 int rc; 737 738 if ((rc = subsystem_register(&ecryptfs_subsys))) { 739 printk(KERN_ERR 740 "Unable to register ecryptfs sysfs subsystem\n"); 741 goto out; 742 } 743 rc = sysfs_create_file(&ecryptfs_subsys.kset.kobj, 744 &sysfs_attr_version.attr); 745 if (rc) { 746 printk(KERN_ERR 747 "Unable to create ecryptfs version attribute\n"); 748 subsystem_unregister(&ecryptfs_subsys); 749 goto out; 750 } 751 rc = sysfs_create_file(&ecryptfs_subsys.kset.kobj, 752 &sysfs_attr_version_str.attr); 753 if (rc) { 754 printk(KERN_ERR 755 "Unable to create ecryptfs version_str attribute\n"); 756 sysfs_remove_file(&ecryptfs_subsys.kset.kobj, 757 &sysfs_attr_version.attr); 758 subsystem_unregister(&ecryptfs_subsys); 759 goto out; 760 } 761 out: 762 return rc; 763 } 764 765 static int __init ecryptfs_init(void) 766 { 767 int rc; 768 769 if (ECRYPTFS_DEFAULT_EXTENT_SIZE > PAGE_CACHE_SIZE) { 770 rc = -EINVAL; 771 ecryptfs_printk(KERN_ERR, "The eCryptfs extent size is " 772 "larger than the host's page size, and so " 773 "eCryptfs cannot run on this system. The " 774 "default eCryptfs extent size is [%d] bytes; " 775 "the page size is [%d] bytes.\n", 776 ECRYPTFS_DEFAULT_EXTENT_SIZE, PAGE_CACHE_SIZE); 777 goto out; 778 } 779 rc = ecryptfs_init_kmem_caches(); 780 if (rc) { 781 printk(KERN_ERR 782 "Failed to allocate one or more kmem_cache objects\n"); 783 goto out; 784 } 785 rc = register_filesystem(&ecryptfs_fs_type); 786 if (rc) { 787 printk(KERN_ERR "Failed to register filesystem\n"); 788 ecryptfs_free_kmem_caches(); 789 goto out; 790 } 791 kset_set_kset_s(&ecryptfs_subsys, fs_subsys); 792 sysfs_attr_version.attr.owner = THIS_MODULE; 793 sysfs_attr_version_str.attr.owner = THIS_MODULE; 794 rc = do_sysfs_registration(); 795 if (rc) { 796 printk(KERN_ERR "sysfs registration failed\n"); 797 unregister_filesystem(&ecryptfs_fs_type); 798 ecryptfs_free_kmem_caches(); 799 goto out; 800 } 801 out: 802 return rc; 803 } 804 805 static void __exit ecryptfs_exit(void) 806 { 807 sysfs_remove_file(&ecryptfs_subsys.kset.kobj, 808 &sysfs_attr_version.attr); 809 sysfs_remove_file(&ecryptfs_subsys.kset.kobj, 810 &sysfs_attr_version_str.attr); 811 subsystem_unregister(&ecryptfs_subsys); 812 unregister_filesystem(&ecryptfs_fs_type); 813 ecryptfs_free_kmem_caches(); 814 } 815 816 MODULE_AUTHOR("Michael A. Halcrow <mhalcrow@us.ibm.com>"); 817 MODULE_DESCRIPTION("eCryptfs"); 818 819 MODULE_LICENSE("GPL"); 820 821 module_init(ecryptfs_init) 822 module_exit(ecryptfs_exit) 823