main.c 25.3 KB
Newer Older
1 2 3 4 5
/**
 * eCryptfs: Linux filesystem encryption layer
 *
 * Copyright (C) 1997-2003 Erez Zadok
 * Copyright (C) 2001-2003 Stony Brook University
6
 * Copyright (C) 2004-2007 International Business Machines Corp.
7 8
 *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
 *              Michael C. Thompson <mcthomps@us.ibm.com>
9
 *              Tyler Hicks <tyhicks@ou.edu>
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *
 * 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/mount.h>
#include <linux/pagemap.h>
#include <linux/key.h>
#include <linux/parser.h>
36
#include <linux/fs_stack.h>
37
#include <linux/slab.h>
38
#include <linux/magic.h>
39 40 41 42 43 44 45 46 47 48 49 50
#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)");

51
/**
52
 * Module parameter that defines the number of message buffer elements
53 54 55 56 57 58 59 60 61
 */
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
62
 * for a response from ecryptfsd.  The actual sleep time will be, more than
63
 * likely, a small amount greater than this specified value, but only less if
64
 * the message successfully arrives.
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
 */
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");

85 86 87 88 89 90 91 92 93 94 95 96
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);
}

97
/**
98
 * ecryptfs_init_lower_file
99 100 101 102 103 104 105
 * @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
106 107 108
 * lower file struct and associates it with the eCryptfs
 * inode. When all eCryptfs files associated with the inode are released, the
 * file is closed.
109
 *
110
 * The lower file will be opened with read/write permissions, if
111 112
 * possible. Otherwise, it is opened read-only.
 *
113
 * This function does nothing if a lower file is already
114 115 116 117
 * associated with the eCryptfs inode.
 *
 * Returns zero on success; non-zero otherwise
 */
118 119
static int ecryptfs_init_lower_file(struct dentry *dentry,
				    struct file **lower_file)
120
{
121
	const struct cred *cred = current_cred();
122
	struct path *path = ecryptfs_dentry_to_lower_path(dentry);
123 124
	int rc;

125
	rc = ecryptfs_privileged_open(lower_file, path->dentry, path->mnt,
126 127 128 129
				      cred);
	if (rc) {
		printk(KERN_ERR "Error opening lower file "
		       "for lower_dentry [0x%p] and lower_mnt [0x%p]; "
130
		       "rc = [%d]\n", path->dentry, path->mnt, rc);
131 132 133 134 135
		(*lower_file) = NULL;
	}
	return rc;
}

136
int ecryptfs_get_lower_file(struct dentry *dentry, struct inode *inode)
137
{
138
	struct ecryptfs_inode_info *inode_info;
139
	int count, rc = 0;
140

141
	inode_info = ecryptfs_inode_to_private(inode);
142 143 144 145 146 147 148 149 150
	mutex_lock(&inode_info->lower_file_mutex);
	count = atomic_inc_return(&inode_info->lower_file_count);
	if (WARN_ON_ONCE(count < 1))
		rc = -EINVAL;
	else if (count == 1) {
		rc = ecryptfs_init_lower_file(dentry,
					      &inode_info->lower_file);
		if (rc)
			atomic_set(&inode_info->lower_file_count, 0);
151
	}
152
	mutex_unlock(&inode_info->lower_file_mutex);
153 154 155
	return rc;
}

156 157 158 159 160 161 162
void ecryptfs_put_lower_file(struct inode *inode)
{
	struct ecryptfs_inode_info *inode_info;

	inode_info = ecryptfs_inode_to_private(inode);
	if (atomic_dec_and_mutex_lock(&inode_info->lower_file_count,
				      &inode_info->lower_file_mutex)) {
163
		filemap_write_and_wait(inode->i_mapping);
164 165 166 167 168 169
		fput(inode_info->lower_file);
		inode_info->lower_file = NULL;
		mutex_unlock(&inode_info->lower_file_mutex);
	}
}

170 171 172
enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig,
       ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher,
       ecryptfs_opt_ecryptfs_key_bytes,
173
       ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata,
174 175
       ecryptfs_opt_encrypted_view, ecryptfs_opt_fnek_sig,
       ecryptfs_opt_fn_cipher, ecryptfs_opt_fn_cipher_key_bytes,
176
       ecryptfs_opt_unlink_sigs, ecryptfs_opt_mount_auth_tok_only,
177
       ecryptfs_opt_check_dev_ruid,
178
       ecryptfs_opt_err };
179

180
static const match_table_t tokens = {
181 182 183 184 185 186
	{ecryptfs_opt_sig, "sig=%s"},
	{ecryptfs_opt_ecryptfs_sig, "ecryptfs_sig=%s"},
	{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"},
187 188
	{ecryptfs_opt_xattr_metadata, "ecryptfs_xattr_metadata"},
	{ecryptfs_opt_encrypted_view, "ecryptfs_encrypted_view"},
189 190 191
	{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"},
192
	{ecryptfs_opt_unlink_sigs, "ecryptfs_unlink_sigs"},
193
	{ecryptfs_opt_mount_auth_tok_only, "ecryptfs_mount_auth_tok_only"},
194
	{ecryptfs_opt_check_dev_ruid, "ecryptfs_check_dev_ruid"},
195 196 197
	{ecryptfs_opt_err, NULL}
};

198 199
static int ecryptfs_init_global_auth_toks(
	struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
200
{
201
	struct ecryptfs_global_auth_tok *global_auth_tok;
202
	struct ecryptfs_auth_tok *auth_tok;
203 204
	int rc = 0;

205 206 207
	list_for_each_entry(global_auth_tok,
			    &mount_crypt_stat->global_auth_tok_list,
			    mount_crypt_stat_list) {
208
		rc = ecryptfs_keyring_auth_tok_for_sig(
209
			&global_auth_tok->global_auth_tok_key, &auth_tok,
210 211
			global_auth_tok->sig);
		if (rc) {
212 213 214 215
			printk(KERN_ERR "Could not find valid key in user "
			       "session keyring for sig specified in mount "
			       "option: [%s]\n", global_auth_tok->sig);
			global_auth_tok->flags |= ECRYPTFS_AUTH_TOK_INVALID;
216
			goto out;
217
		} else {
218
			global_auth_tok->flags &= ~ECRYPTFS_AUTH_TOK_INVALID;
219 220
			up_write(&(global_auth_tok->global_auth_tok_key)->sem);
		}
221
	}
222
out:
223 224 225
	return rc;
}

226 227 228 229 230 231 232 233 234 235
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;
}

236 237 238
/**
 * ecryptfs_parse_options
 * @sb: The ecryptfs super block
Lucas De Marchi's avatar
Lucas De Marchi committed
239
 * @options: The options passed to the kernel
240
 * @check_ruid: set to 1 if device uid should be checked against the ruid
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
 *
 * 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
 */
256 257
static int ecryptfs_parse_options(struct ecryptfs_sb_info *sbi, char *options,
				  uid_t *check_ruid)
258 259 260 261 262
{
	char *p;
	int rc = 0;
	int sig_set = 0;
	int cipher_name_set = 0;
263
	int fn_cipher_name_set = 0;
264 265
	int cipher_key_bytes;
	int cipher_key_bytes_set = 0;
266 267
	int fn_cipher_key_bytes;
	int fn_cipher_key_bytes_set = 0;
268
	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
Al Viro's avatar
Al Viro committed
269
		&sbi->mount_crypt_stat;
270 271 272 273 274
	substring_t args[MAX_OPT_ARGS];
	int token;
	char *sig_src;
	char *cipher_name_dst;
	char *cipher_name_src;
275 276 277 278
	char *fn_cipher_name_dst;
	char *fn_cipher_name_src;
	char *fnek_dst;
	char *fnek_src;
279
	char *cipher_key_bytes_src;
280
	char *fn_cipher_key_bytes_src;
281
	u8 cipher_code;
282

283 284
	*check_ruid = 0;

285 286 287 288
	if (!options) {
		rc = -EINVAL;
		goto out;
	}
289
	ecryptfs_init_mount_crypt_stat(mount_crypt_stat);
290 291 292 293 294 295 296 297
	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;
298
			rc = ecryptfs_add_global_auth_tok(mount_crypt_stat,
299
							  sig_src, 0);
300 301 302 303 304
			if (rc) {
				printk(KERN_ERR "Error attempting to register "
				       "global sig; rc = [%d]\n", rc);
				goto out;
			}
305 306 307 308 309 310 311 312 313 314
			sig_set = 1;
			break;
		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);
315
			cipher_name_dst[ECRYPTFS_MAX_CIPHER_NAME_SIZE] = '\0';
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
			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;
			cipher_key_bytes_set = 1;
			break;
		case ecryptfs_opt_passthrough:
			mount_crypt_stat->flags |=
				ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED;
			break;
331 332 333 334 335 336 337 338 339 340
		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;
341 342 343 344 345 346 347 348 349
		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,
350 351
				mount_crypt_stat->global_default_fnek_sig,
				ECRYPTFS_AUTH_TOK_FNEK);
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
			if (rc) {
				printk(KERN_ERR "Error attempting to register "
				       "global fnek sig [%s]; rc = [%d]\n",
				       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;
382 383 384
		case ecryptfs_opt_unlink_sigs:
			mount_crypt_stat->flags |= ECRYPTFS_UNLINK_SIGS;
			break;
385 386 387 388
		case ecryptfs_opt_mount_auth_tok_only:
			mount_crypt_stat->flags |=
				ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY;
			break;
389 390 391
		case ecryptfs_opt_check_dev_ruid:
			*check_ruid = 1;
			break;
392 393
		case ecryptfs_opt_err:
		default:
394 395 396
			printk(KERN_WARNING
			       "%s: eCryptfs: unrecognized option [%s]\n",
			       __func__, p);
397 398 399 400
		}
	}
	if (!sig_set) {
		rc = -EINVAL;
401 402
		ecryptfs_printk(KERN_ERR, "You must supply at least one valid "
				"auth tok signature as a mount "
403 404 405 406
				"parameter; see the eCryptfs README\n");
		goto out;
	}
	if (!cipher_name_set) {
407 408
		int cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER);

409
		BUG_ON(cipher_name_len > ECRYPTFS_MAX_CIPHER_NAME_SIZE);
410 411
		strcpy(mount_crypt_stat->global_default_cipher_name,
		       ECRYPTFS_DEFAULT_CIPHER);
412
	}
413 414 415 416 417
	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)
418
		mount_crypt_stat->global_default_cipher_key_size = 0;
419 420 421 422
	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;
423 424 425 426 427 428

	cipher_code = ecryptfs_code_for_cipher_string(
		mount_crypt_stat->global_default_cipher_name,
		mount_crypt_stat->global_default_cipher_key_size);
	if (!cipher_code) {
		ecryptfs_printk(KERN_ERR,
429
				"eCryptfs doesn't support cipher: %s\n",
430 431 432 433 434
				mount_crypt_stat->global_default_cipher_name);
		rc = -EINVAL;
		goto out;
	}

435 436
	mutex_lock(&key_tfm_list_mutex);
	if (!ecryptfs_tfm_exists(mount_crypt_stat->global_default_cipher_name,
437
				 NULL)) {
438 439 440
		rc = ecryptfs_add_new_key_tfm(
			NULL, mount_crypt_stat->global_default_cipher_name,
			mount_crypt_stat->global_default_cipher_key_size);
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
		if (rc) {
			printk(KERN_ERR "Error attempting to initialize "
			       "cipher with name = [%s] and key size = [%td]; "
			       "rc = [%d]\n",
			       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]\n",
			       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;
		}
470
	}
471
	mutex_unlock(&key_tfm_list_mutex);
472
	rc = ecryptfs_init_global_auth_toks(mount_crypt_stat);
473
	if (rc)
474 475
		printk(KERN_WARNING "One or more global auth toks could not "
		       "properly register; rc = [%d]\n", rc);
476 477 478 479 480
out:
	return rc;
}

struct kmem_cache *ecryptfs_sb_info_cache;
Al Viro's avatar
Al Viro committed
481
static struct file_system_type ecryptfs_fs_type;
482 483 484 485 486 487 488 489

/**
 * ecryptfs_get_sb
 * @fs_type
 * @flags
 * @dev_name: The path to mount over
 * @raw_data: The options passed into the kernel
 */
Al Viro's avatar
Al Viro committed
490 491
static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags,
			const char *dev_name, void *raw_data)
492
{
Al Viro's avatar
Al Viro committed
493 494
	struct super_block *s;
	struct ecryptfs_sb_info *sbi;
495
	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
Al Viro's avatar
Al Viro committed
496 497
	struct ecryptfs_dentry_info *root_info;
	const char *err = "Getting sb failed";
Al Viro's avatar
Al Viro committed
498 499
	struct inode *inode;
	struct path path;
500
	uid_t check_ruid;
501 502
	int rc;

Al Viro's avatar
Al Viro committed
503 504 505
	sbi = kmem_cache_zalloc(ecryptfs_sb_info_cache, GFP_KERNEL);
	if (!sbi) {
		rc = -ENOMEM;
506 507
		goto out;
	}
Al Viro's avatar
Al Viro committed
508

509
	rc = ecryptfs_parse_options(sbi, raw_data, &check_ruid);
510
	if (rc) {
Al Viro's avatar
Al Viro committed
511 512
		err = "Error parsing options";
		goto out;
513
	}
514
	mount_crypt_stat = &sbi->mount_crypt_stat;
Al Viro's avatar
Al Viro committed
515

516
	s = sget(fs_type, NULL, set_anon_super, flags, NULL);
Al Viro's avatar
Al Viro committed
517 518 519 520 521
	if (IS_ERR(s)) {
		rc = PTR_ERR(s);
		goto out;
	}

522
	rc = super_setup_bdi(s);
Al Viro's avatar
Al Viro committed
523 524
	if (rc)
		goto out1;
Al Viro's avatar
Al Viro committed
525 526 527 528 529 530

	ecryptfs_set_superblock_private(s, sbi);

	/* ->kill_sb() will take care of sbi after that point */
	sbi = NULL;
	s->s_op = &ecryptfs_sops;
531
	s->s_xattr = ecryptfs_xattr_handlers;
Al Viro's avatar
Al Viro committed
532
	s->s_d_op = &ecryptfs_dops;
Al Viro's avatar
Al Viro committed
533

Al Viro's avatar
Al Viro committed
534 535 536 537 538 539 540 541 542 543 544 545 546
	err = "Reading sb failed";
	rc = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
	if (rc) {
		ecryptfs_printk(KERN_WARNING, "kern_path() failed\n");
		goto out1;
	}
	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\n");
		goto out_free;
	}
547

548
	if (check_ruid && !uid_eq(d_inode(path.dentry)->i_uid, current_uid())) {
549 550 551
		rc = -EPERM;
		printk(KERN_ERR "Mount of device (uid: %d) not owned by "
		       "requested user (uid: %d)\n",
552
			i_uid_read(d_inode(path.dentry)),
553
			from_kuid(&init_user_ns, current_uid()));
554 555 556
		goto out_free;
	}

Al Viro's avatar
Al Viro committed
557
	ecryptfs_set_superblock_lower(s, path.dentry->d_sb);
558 559 560

	/**
	 * Set the POSIX ACL flag based on whether they're enabled in the lower
561
	 * mount.
562
	 */
563 564
	s->s_flags = flags & ~SB_POSIXACL;
	s->s_flags |= path.dentry->d_sb->s_flags & SB_POSIXACL;
565 566 567 568 569 570

	/**
	 * Force a read-only eCryptfs mount when:
	 *   1) The lower mount is ro
	 *   2) The ecryptfs_encrypted_view mount option is specified
	 */
571
	if (sb_rdonly(path.dentry->d_sb) || mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
572
		s->s_flags |= SB_RDONLY;
573

Al Viro's avatar
Al Viro committed
574 575
	s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
	s->s_blocksize = path.dentry->d_sb->s_blocksize;
576
	s->s_magic = ECRYPTFS_SUPER_MAGIC;
577 578 579 580 581 582 583
	s->s_stack_depth = path.dentry->d_sb->s_stack_depth + 1;

	rc = -EINVAL;
	if (s->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
		pr_err("eCryptfs: maximum fs stacking depth exceeded\n");
		goto out_free;
	}
Al Viro's avatar
Al Viro committed
584

585
	inode = ecryptfs_get_inode(d_inode(path.dentry), s);
Al Viro's avatar
Al Viro committed
586 587 588 589
	rc = PTR_ERR(inode);
	if (IS_ERR(inode))
		goto out_free;

590
	s->s_root = d_make_root(inode);
Al Viro's avatar
Al Viro committed
591
	if (!s->s_root) {
Al Viro's avatar
Al Viro committed
592 593
		rc = -ENOMEM;
		goto out_free;
Al Viro's avatar
Al Viro committed
594 595
	}

Al Viro's avatar
Al Viro committed
596
	rc = -ENOMEM;
Al Viro's avatar
Al Viro committed
597
	root_info = kmem_cache_zalloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
Al Viro's avatar
Al Viro committed
598 599 600
	if (!root_info)
		goto out_free;

Al Viro's avatar
Al Viro committed
601 602
	/* ->kill_sb() will take care of root_info */
	ecryptfs_set_dentry_private(s->s_root, root_info);
603
	root_info->lower_path = path;
Al Viro's avatar
Al Viro committed
604

605
	s->s_flags |= SB_ACTIVE;
Al Viro's avatar
Al Viro committed
606
	return dget(s->s_root);
Al Viro's avatar
Al Viro committed
607

Al Viro's avatar
Al Viro committed
608 609 610 611
out_free:
	path_put(&path);
out1:
	deactivate_locked_super(s);
612
out:
Al Viro's avatar
Al Viro committed
613 614 615 616 617
	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]\n", err, rc);
Al Viro's avatar
Al Viro committed
618
	return ERR_PTR(rc);
619 620 621 622 623 624 625 626 627 628
}

/**
 * ecryptfs_kill_block_super
 * @sb: The ecryptfs super block
 *
 * Used to bring the superblock down and free the private data.
 */
static void ecryptfs_kill_block_super(struct super_block *sb)
{
Al Viro's avatar
Al Viro committed
629 630 631 632 633 634
	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);
	kmem_cache_free(ecryptfs_sb_info_cache, sb_info);
635 636 637 638 639
}

static struct file_system_type ecryptfs_fs_type = {
	.owner = THIS_MODULE,
	.name = "ecryptfs",
Al Viro's avatar
Al Viro committed
640
	.mount = ecryptfs_mount,
641 642 643
	.kill_sb = ecryptfs_kill_block_super,
	.fs_flags = 0
};
644
MODULE_ALIAS_FS("ecryptfs");
645 646 647 648 649 650 651

/**
 * inode_info_init_once
 *
 * Initializes the ecryptfs_inode_info_cache when it is created
 */
static void
652
inode_info_init_once(void *vptr)
653 654 655
{
	struct ecryptfs_inode_info *ei = (struct ecryptfs_inode_info *)vptr;

656
	inode_init_once(&ei->vfs_inode);
657 658 659
}

static struct ecryptfs_cache_info {
660
	struct kmem_cache **cache;
661 662
	const char *name;
	size_t size;
663
	slab_flags_t flags;
664
	void (*ctor)(void *obj);
665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
} 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),
685
		.flags = SLAB_ACCOUNT,
686 687 688 689 690 691 692 693
		.ctor = inode_info_init_once,
	},
	{
		.cache = &ecryptfs_sb_info_cache,
		.name = "ecryptfs_sb_cache",
		.size = sizeof(struct ecryptfs_sb_info),
	},
	{
694 695
		.cache = &ecryptfs_header_cache,
		.name = "ecryptfs_headers",
696
		.size = PAGE_SIZE,
697
	},
698 699 700
	{
		.cache = &ecryptfs_xattr_cache,
		.name = "ecryptfs_xattr_cache",
701
		.size = PAGE_SIZE,
702
	},
703 704 705 706 707
	{
		.cache = &ecryptfs_key_record_cache,
		.name = "ecryptfs_key_record_cache",
		.size = sizeof(struct ecryptfs_key_record),
	},
708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
	{
		.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),
	},
723 724 725 726 727 728
};

static void ecryptfs_free_kmem_caches(void)
{
	int i;

729 730 731 732 733 734
	/*
	 * Make sure all delayed rcu free inodes are flushed before we
	 * destroy cache.
	 */
	rcu_barrier();

735 736 737 738
	for (i = 0; i < ARRAY_SIZE(ecryptfs_cache_infos); i++) {
		struct ecryptfs_cache_info *info;

		info = &ecryptfs_cache_infos[i];
739
		kmem_cache_destroy(*(info->cache));
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
	}
}

/**
 * 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];
756 757
		*(info->cache) = kmem_cache_create(info->name, info->size, 0,
				SLAB_HWCACHE_ALIGN | info->flags, info->ctor);
758 759 760 761 762 763 764 765 766 767 768
		if (!*(info->cache)) {
			ecryptfs_free_kmem_caches();
			ecryptfs_printk(KERN_WARNING, "%s: "
					"kmem_cache_create failed\n",
					info->name);
			return -ENOMEM;
		}
	}
	return 0;
}

769
static struct kobject *ecryptfs_kobj;
770

771 772
static ssize_t version_show(struct kobject *kobj,
			    struct kobj_attribute *attr, char *buff)
773 774 775 776
{
	return snprintf(buff, PAGE_SIZE, "%d\n", ECRYPTFS_VERSIONING_MASK);
}

777
static struct kobj_attribute version_attr = __ATTR_RO(version);
778

779 780 781 782 783
static struct attribute *attributes[] = {
	&version_attr.attr,
	NULL,
};

784
static const struct attribute_group attr_group = {
785 786
	.attrs = attributes,
};
787 788 789 790 791

static int do_sysfs_registration(void)
{
	int rc;

792 793
	ecryptfs_kobj = kobject_create_and_add("ecryptfs", fs_kobj);
	if (!ecryptfs_kobj) {
794 795
		printk(KERN_ERR "Unable to create ecryptfs kset\n");
		rc = -ENOMEM;
796 797
		goto out;
	}
798
	rc = sysfs_create_group(ecryptfs_kobj, &attr_group);
799 800
	if (rc) {
		printk(KERN_ERR
801
		       "Unable to create ecryptfs version attributes\n");
802
		kobject_put(ecryptfs_kobj);
803 804 805 806 807
	}
out:
	return rc;
}

808 809
static void do_sysfs_unregistration(void)
{
810
	sysfs_remove_group(ecryptfs_kobj, &attr_group);
811
	kobject_put(ecryptfs_kobj);
812 813
}

814 815 816 817
static int __init ecryptfs_init(void)
{
	int rc;

818
	if (ECRYPTFS_DEFAULT_EXTENT_SIZE > PAGE_SIZE) {
819 820 821 822
		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 "
823 824 825
				"default eCryptfs extent size is [%u] bytes; "
				"the page size is [%lu] bytes.\n",
				ECRYPTFS_DEFAULT_EXTENT_SIZE,
826
				(unsigned long)PAGE_SIZE);
827 828 829 830 831 832 833 834 835 836 837
		goto out;
	}
	rc = ecryptfs_init_kmem_caches();
	if (rc) {
		printk(KERN_ERR
		       "Failed to allocate one or more kmem_cache objects\n");
		goto out;
	}
	rc = do_sysfs_registration();
	if (rc) {
		printk(KERN_ERR "sysfs registration failed\n");
838
		goto out_free_kmem_caches;
839
	}
840 841 842 843 844 845
	rc = ecryptfs_init_kthread();
	if (rc) {
		printk(KERN_ERR "%s: kthread initialization failed; "
		       "rc = [%d]\n", __func__, rc);
		goto out_do_sysfs_unregistration;
	}
846
	rc = ecryptfs_init_messaging();
847
	if (rc) {
Lucas De Marchi's avatar
Lucas De Marchi committed
848
		printk(KERN_ERR "Failure occurred while attempting to "
849 850
				"initialize the communications channel to "
				"ecryptfsd\n");
851
		goto out_destroy_kthread;
852 853 854 855 856
	}
	rc = ecryptfs_init_crypto();
	if (rc) {
		printk(KERN_ERR "Failure whilst attempting to init crypto; "
		       "rc = [%d]\n", rc);
857
		goto out_release_messaging;
858
	}
859 860 861 862 863
	rc = register_filesystem(&ecryptfs_fs_type);
	if (rc) {
		printk(KERN_ERR "Failed to register filesystem\n");
		goto out_destroy_crypto;
	}
864 865 866 867
	if (ecryptfs_verbosity > 0)
		printk(KERN_CRIT "eCryptfs verbosity set to %d. Secret values "
			"will be written to the syslog!\n", ecryptfs_verbosity);

868
	goto out;
869 870
out_destroy_crypto:
	ecryptfs_destroy_crypto();
871
out_release_messaging:
872
	ecryptfs_release_messaging();
873 874
out_destroy_kthread:
	ecryptfs_destroy_kthread();
875 876 877 878
out_do_sysfs_unregistration:
	do_sysfs_unregistration();
out_free_kmem_caches:
	ecryptfs_free_kmem_caches();
879 880 881 882 883 884
out:
	return rc;
}

static void __exit ecryptfs_exit(void)
{
885 886 887 888 889 890
	int rc;

	rc = ecryptfs_destroy_crypto();
	if (rc)
		printk(KERN_ERR "Failure whilst attempting to destroy crypto; "
		       "rc = [%d]\n", rc);
891
	ecryptfs_release_messaging();
892
	ecryptfs_destroy_kthread();
893
	do_sysfs_unregistration();
894 895 896 897 898 899 900 901 902 903 904
	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)