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