![Tejun Heo](/assets/img/avatar_default.png)
percpu.h is included by sched.h and module.h and thus ends up being included when building most .c files. percpu.h includes slab.h which in turn includes gfp.h making everything defined by the two files universally available and complicating inclusion dependencies. percpu.h -> slab.h dependency is about to be removed. Prepare for this change by updating users of gfp and slab facilities include those headers directly instead of assuming availability. As this conversion needs to touch large number of source files, the following script is used as the basis of conversion. http://userweb.kernel.org/~tj/misc/slabh-sweep.py The script does the followings. * Scan files for gfp and slab usages and update includes such that only the necessary includes are there. ie. if only gfp is used, gfp.h, if slab is used, slab.h. * When the script inserts a new include, it looks at the include blocks and try to put the new include such that its order conforms to its surrounding. It's put in the include block which contains core kernel includes, in the same order that the rest are ordered - alphabetical, Christmas tree, rev-Xmas-tree or at the end if there doesn't seem to be any matching order. * If the script can't find a place to put a new include (mostly because the file doesn't have fitting include block), it prints out an error message indicating which .h file needs to be added to the file. The conversion was done in the following steps. 1. The initial automatic conversion of all .c files updated slightly over 4000 files, deleting around 700 includes and adding ~480 gfp.h and ~3000 slab.h inclusions. The script emitted errors for ~400 files. 2. Each error was manually checked. Some didn't need the inclusion, some needed manual addition while adding it to implementation .h or embedding .c file was more appropriate for others. This step added inclusions to around 150 files. 3. The script was run again and the output was compared to the edits from #2 to make sure no file was left behind. 4. Several build tests were done and a couple of problems were fixed. e.g. lib/decompress_*.c used malloc/free() wrappers around slab APIs requiring slab.h to be added manually. 5. The script was run on all .h files but without automatically editing them as sprinkling gfp.h and slab.h inclusions around .h files could easily lead to inclusion dependency hell. Most gfp.h inclusion directives were ignored as stuff from gfp.h was usually wildly available and often used in preprocessor macros. Each slab.h inclusion directive was examined and added manually as necessary. 6. percpu.h was updated not to include slab.h. 7. Build test were done on the following configurations and failures were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my distributed build env didn't work with gcov compiles) and a few more options had to be turned off depending on archs to make things build (like ipr on powerpc/64 which failed due to missing writeq). * x86 and x86_64 UP and SMP allmodconfig and a custom test config. * powerpc and powerpc64 SMP allmodconfig * sparc and sparc64 SMP allmodconfig * ia64 SMP allmodconfig * s390 SMP allmodconfig * alpha SMP allmodconfig * um on x86_64 SMP allmodconfig 8. percpu.h modifications were reverted so that it could be applied as a separate patch and serve as bisection point. Given the fact that I had only a couple of failures from tests on step 6, I'm fairly confident about the coverage of this conversion patch. If there is a breakage, it's likely to be something in one of the arch headers which should be easily discoverable easily on most builds of the specific arch. Signed-off-by: Tejun Heo <tj@kernel.org> Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
904 lines
26 KiB
C
904 lines
26 KiB
C
/**
|
|
* eCryptfs: Linux filesystem encryption layer
|
|
*
|
|
* Copyright (C) 1997-2003 Erez Zadok
|
|
* Copyright (C) 2001-2003 Stony Brook University
|
|
* Copyright (C) 2004-2007 International Business Machines Corp.
|
|
* Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
|
|
* Michael C. Thompson <mcthomps@us.ibm.com>
|
|
* Tyler Hicks <tyhicks@ou.edu>
|
|
*
|
|
* 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>
|
|
#include <linux/mount.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/key.h>
|
|
#include <linux/parser.h>
|
|
#include <linux/fs_stack.h>
|
|
#include <linux/slab.h>
|
|
#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)");
|
|
|
|
/**
|
|
* Module parameter that defines the number of message buffer elements
|
|
*/
|
|
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
|
|
* for a response from ecryptfsd. The actual sleep time will be, more than
|
|
* likely, a small amount greater than this specified value, but only less if
|
|
* the message successfully arrives.
|
|
*/
|
|
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");
|
|
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
|
|
{
|
|
const struct cred *cred = current_cred();
|
|
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);
|
|
rc = ecryptfs_privileged_open(&inode_info->lower_file,
|
|
lower_dentry, lower_mnt, cred);
|
|
if (rc) {
|
|
printk(KERN_ERR "Error opening lower persistent file "
|
|
"for lower_dentry [0x%p] and lower_mnt [0x%p]; "
|
|
"rc = [%d]\n", lower_dentry, lower_mnt, rc);
|
|
inode_info->lower_file = NULL;
|
|
}
|
|
}
|
|
mutex_unlock(&inode_info->lower_file_mutex);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ecryptfs_interpose
|
|
* @lower_dentry: Existing dentry in the lower filesystem
|
|
* @dentry: ecryptfs' dentry
|
|
* @sb: ecryptfs's super_block
|
|
* @flags: flags to govern behavior of interpose procedure
|
|
*
|
|
* Interposes upper and lower dentries.
|
|
*
|
|
* Returns zero on success; non-zero otherwise
|
|
*/
|
|
int ecryptfs_interpose(struct dentry *lower_dentry, struct dentry *dentry,
|
|
struct super_block *sb, u32 flags)
|
|
{
|
|
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;
|
|
if (special_file(lower_inode->i_mode))
|
|
init_special_inode(inode, lower_inode->i_mode,
|
|
lower_inode->i_rdev);
|
|
dentry->d_op = &ecryptfs_dops;
|
|
fsstack_copy_attr_all(inode, lower_inode);
|
|
/* This size will be overwritten for real files w/ headers and
|
|
* other metadata */
|
|
fsstack_copy_inode_size(inode, lower_inode);
|
|
if (flags & ECRYPTFS_INTERPOSE_FLAG_D_ADD)
|
|
d_add(dentry, inode);
|
|
else
|
|
d_instantiate(dentry, inode);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig,
|
|
ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher,
|
|
ecryptfs_opt_ecryptfs_key_bytes,
|
|
ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata,
|
|
ecryptfs_opt_encrypted_view, ecryptfs_opt_fnek_sig,
|
|
ecryptfs_opt_fn_cipher, ecryptfs_opt_fn_cipher_key_bytes,
|
|
ecryptfs_opt_unlink_sigs, ecryptfs_opt_err };
|
|
|
|
static const match_table_t tokens = {
|
|
{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"},
|
|
{ecryptfs_opt_xattr_metadata, "ecryptfs_xattr_metadata"},
|
|
{ecryptfs_opt_encrypted_view, "ecryptfs_encrypted_view"},
|
|
{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"},
|
|
{ecryptfs_opt_unlink_sigs, "ecryptfs_unlink_sigs"},
|
|
{ecryptfs_opt_err, NULL}
|
|
};
|
|
|
|
static int ecryptfs_init_global_auth_toks(
|
|
struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
|
|
{
|
|
struct ecryptfs_global_auth_tok *global_auth_tok;
|
|
int rc = 0;
|
|
|
|
list_for_each_entry(global_auth_tok,
|
|
&mount_crypt_stat->global_auth_tok_list,
|
|
mount_crypt_stat_list) {
|
|
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) {
|
|
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;
|
|
goto out;
|
|
} else
|
|
global_auth_tok->flags &= ~ECRYPTFS_AUTH_TOK_INVALID;
|
|
}
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
static int ecryptfs_parse_options(struct super_block *sb, char *options)
|
|
{
|
|
char *p;
|
|
int rc = 0;
|
|
int sig_set = 0;
|
|
int cipher_name_set = 0;
|
|
int fn_cipher_name_set = 0;
|
|
int cipher_key_bytes;
|
|
int cipher_key_bytes_set = 0;
|
|
int fn_cipher_key_bytes;
|
|
int fn_cipher_key_bytes_set = 0;
|
|
struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
|
|
&ecryptfs_superblock_to_private(sb)->mount_crypt_stat;
|
|
substring_t args[MAX_OPT_ARGS];
|
|
int token;
|
|
char *sig_src;
|
|
char *cipher_name_dst;
|
|
char *cipher_name_src;
|
|
char *fn_cipher_name_dst;
|
|
char *fn_cipher_name_src;
|
|
char *fnek_dst;
|
|
char *fnek_src;
|
|
char *cipher_key_bytes_src;
|
|
char *fn_cipher_key_bytes_src;
|
|
|
|
if (!options) {
|
|
rc = -EINVAL;
|
|
goto out;
|
|
}
|
|
ecryptfs_init_mount_crypt_stat(mount_crypt_stat);
|
|
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;
|
|
rc = ecryptfs_add_global_auth_tok(mount_crypt_stat,
|
|
sig_src, 0);
|
|
if (rc) {
|
|
printk(KERN_ERR "Error attempting to register "
|
|
"global sig; rc = [%d]\n", rc);
|
|
goto out;
|
|
}
|
|
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);
|
|
cipher_name_dst[ECRYPTFS_MAX_CIPHER_NAME_SIZE] = '\0';
|
|
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;
|
|
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;
|
|
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,
|
|
mount_crypt_stat->global_default_fnek_sig,
|
|
ECRYPTFS_AUTH_TOK_FNEK);
|
|
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;
|
|
case ecryptfs_opt_unlink_sigs:
|
|
mount_crypt_stat->flags |= ECRYPTFS_UNLINK_SIGS;
|
|
break;
|
|
case ecryptfs_opt_err:
|
|
default:
|
|
printk(KERN_WARNING
|
|
"%s: eCryptfs: unrecognized option [%s]\n",
|
|
__func__, p);
|
|
}
|
|
}
|
|
if (!sig_set) {
|
|
rc = -EINVAL;
|
|
ecryptfs_printk(KERN_ERR, "You must supply at least one valid "
|
|
"auth tok signature as a mount "
|
|
"parameter; see the eCryptfs README\n");
|
|
goto out;
|
|
}
|
|
if (!cipher_name_set) {
|
|
int cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER);
|
|
|
|
BUG_ON(cipher_name_len >= ECRYPTFS_MAX_CIPHER_NAME_SIZE);
|
|
strcpy(mount_crypt_stat->global_default_cipher_name,
|
|
ECRYPTFS_DEFAULT_CIPHER);
|
|
}
|
|
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)
|
|
mount_crypt_stat->global_default_cipher_key_size = 0;
|
|
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;
|
|
mutex_lock(&key_tfm_list_mutex);
|
|
if (!ecryptfs_tfm_exists(mount_crypt_stat->global_default_cipher_name,
|
|
NULL)) {
|
|
rc = ecryptfs_add_new_key_tfm(
|
|
NULL, mount_crypt_stat->global_default_cipher_name,
|
|
mount_crypt_stat->global_default_cipher_key_size);
|
|
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;
|
|
}
|
|
}
|
|
mutex_unlock(&key_tfm_list_mutex);
|
|
rc = ecryptfs_init_global_auth_toks(mount_crypt_stat);
|
|
if (rc)
|
|
printk(KERN_WARNING "One or more global auth toks could not "
|
|
"properly register; rc = [%d]\n", rc);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
struct kmem_cache *ecryptfs_sb_info_cache;
|
|
|
|
/**
|
|
* ecryptfs_fill_super
|
|
* @sb: The ecryptfs super block
|
|
* @raw_data: The options passed to mount
|
|
* @silent: Not used but required by function prototype
|
|
*
|
|
* Sets up what we can of the sb, rest is done in ecryptfs_read_super
|
|
*
|
|
* Returns zero on success; non-zero otherwise
|
|
*/
|
|
static int
|
|
ecryptfs_fill_super(struct super_block *sb, void *raw_data, int silent)
|
|
{
|
|
int rc = 0;
|
|
|
|
/* Released in ecryptfs_put_super() */
|
|
ecryptfs_set_superblock_private(sb,
|
|
kmem_cache_zalloc(ecryptfs_sb_info_cache,
|
|
GFP_KERNEL));
|
|
if (!ecryptfs_superblock_to_private(sb)) {
|
|
ecryptfs_printk(KERN_WARNING, "Out of memory\n");
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
sb->s_op = &ecryptfs_sops;
|
|
/* Released through deactivate_super(sb) from get_sb_nodev */
|
|
sb->s_root = d_alloc(NULL, &(const struct qstr) {
|
|
.hash = 0,.name = "/",.len = 1});
|
|
if (!sb->s_root) {
|
|
ecryptfs_printk(KERN_ERR, "d_alloc failed\n");
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
sb->s_root->d_op = &ecryptfs_dops;
|
|
sb->s_root->d_sb = sb;
|
|
sb->s_root->d_parent = sb->s_root;
|
|
/* Released in d_release when dput(sb->s_root) is called */
|
|
/* through deactivate_super(sb) from get_sb_nodev() */
|
|
ecryptfs_set_dentry_private(sb->s_root,
|
|
kmem_cache_zalloc(ecryptfs_dentry_info_cache,
|
|
GFP_KERNEL));
|
|
if (!ecryptfs_dentry_to_private(sb->s_root)) {
|
|
ecryptfs_printk(KERN_ERR,
|
|
"dentry_info_cache alloc failed\n");
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
rc = 0;
|
|
out:
|
|
/* Should be able to rely on deactivate_super called from
|
|
* get_sb_nodev */
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
struct path path;
|
|
int rc;
|
|
|
|
rc = kern_path(dev_name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, &path);
|
|
if (rc) {
|
|
ecryptfs_printk(KERN_WARNING, "path_lookup() failed\n");
|
|
goto out;
|
|
}
|
|
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);
|
|
if (rc)
|
|
goto out_free;
|
|
rc = 0;
|
|
goto out;
|
|
out_free:
|
|
path_put(&path);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ecryptfs_get_sb
|
|
* @fs_type
|
|
* @flags
|
|
* @dev_name: The path to mount over
|
|
* @raw_data: The options passed into the kernel
|
|
*
|
|
* The whole ecryptfs_get_sb process is broken into 4 functions:
|
|
* ecryptfs_parse_options(): handle options passed to ecryptfs, if any
|
|
* ecryptfs_fill_super(): used by get_sb_nodev, fills out the super_block
|
|
* with as much information as it can before needing
|
|
* the lower filesystem.
|
|
* ecryptfs_read_super(): this accesses the lower filesystem and uses
|
|
* ecryptfs_interpose to perform most of the linking
|
|
* ecryptfs_interpose(): links the lower filesystem into ecryptfs (inode.c)
|
|
*/
|
|
static int ecryptfs_get_sb(struct file_system_type *fs_type, int flags,
|
|
const char *dev_name, void *raw_data,
|
|
struct vfsmount *mnt)
|
|
{
|
|
int rc;
|
|
struct super_block *sb;
|
|
|
|
rc = get_sb_nodev(fs_type, flags, raw_data, ecryptfs_fill_super, mnt);
|
|
if (rc < 0) {
|
|
printk(KERN_ERR "Getting sb failed; rc = [%d]\n", rc);
|
|
goto out;
|
|
}
|
|
sb = mnt->mnt_sb;
|
|
rc = ecryptfs_parse_options(sb, raw_data);
|
|
if (rc) {
|
|
printk(KERN_ERR "Error parsing options; rc = [%d]\n", rc);
|
|
goto out_abort;
|
|
}
|
|
rc = ecryptfs_read_super(sb, dev_name);
|
|
if (rc) {
|
|
printk(KERN_ERR "Reading sb failed; rc = [%d]\n", rc);
|
|
goto out_abort;
|
|
}
|
|
goto out;
|
|
out_abort:
|
|
dput(sb->s_root); /* aka mnt->mnt_root, as set by get_sb_nodev() */
|
|
deactivate_locked_super(sb);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ecryptfs_kill_block_super
|
|
* @sb: The ecryptfs super block
|
|
*
|
|
* Used to bring the superblock down and free the private data.
|
|
* Private data is free'd in ecryptfs_put_super()
|
|
*/
|
|
static void ecryptfs_kill_block_super(struct super_block *sb)
|
|
{
|
|
generic_shutdown_super(sb);
|
|
}
|
|
|
|
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
|
|
inode_info_init_once(void *vptr)
|
|
{
|
|
struct ecryptfs_inode_info *ei = (struct ecryptfs_inode_info *)vptr;
|
|
|
|
inode_init_once(&ei->vfs_inode);
|
|
}
|
|
|
|
static struct ecryptfs_cache_info {
|
|
struct kmem_cache **cache;
|
|
const char *name;
|
|
size_t size;
|
|
void (*ctor)(void *obj);
|
|
} 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),
|
|
},
|
|
{
|
|
.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,
|
|
},
|
|
{
|
|
.cache = &ecryptfs_xattr_cache,
|
|
.name = "ecryptfs_xattr_cache",
|
|
.size = PAGE_CACHE_SIZE,
|
|
},
|
|
{
|
|
.cache = &ecryptfs_key_record_cache,
|
|
.name = "ecryptfs_key_record_cache",
|
|
.size = sizeof(struct ecryptfs_key_record),
|
|
},
|
|
{
|
|
.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),
|
|
},
|
|
{
|
|
.cache = &ecryptfs_open_req_cache,
|
|
.name = "ecryptfs_open_req_cache",
|
|
.size = sizeof(struct ecryptfs_open_req),
|
|
},
|
|
};
|
|
|
|
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,
|
|
0, SLAB_HWCACHE_ALIGN, info->ctor);
|
|
if (!*(info->cache)) {
|
|
ecryptfs_free_kmem_caches();
|
|
ecryptfs_printk(KERN_WARNING, "%s: "
|
|
"kmem_cache_create failed\n",
|
|
info->name);
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static struct kobject *ecryptfs_kobj;
|
|
|
|
static ssize_t version_show(struct kobject *kobj,
|
|
struct kobj_attribute *attr, char *buff)
|
|
{
|
|
return snprintf(buff, PAGE_SIZE, "%d\n", ECRYPTFS_VERSIONING_MASK);
|
|
}
|
|
|
|
static struct kobj_attribute version_attr = __ATTR_RO(version);
|
|
|
|
static struct attribute *attributes[] = {
|
|
&version_attr.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group attr_group = {
|
|
.attrs = attributes,
|
|
};
|
|
|
|
static int do_sysfs_registration(void)
|
|
{
|
|
int rc;
|
|
|
|
ecryptfs_kobj = kobject_create_and_add("ecryptfs", fs_kobj);
|
|
if (!ecryptfs_kobj) {
|
|
printk(KERN_ERR "Unable to create ecryptfs kset\n");
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
rc = sysfs_create_group(ecryptfs_kobj, &attr_group);
|
|
if (rc) {
|
|
printk(KERN_ERR
|
|
"Unable to create ecryptfs version attributes\n");
|
|
kobject_put(ecryptfs_kobj);
|
|
}
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
static void do_sysfs_unregistration(void)
|
|
{
|
|
sysfs_remove_group(ecryptfs_kobj, &attr_group);
|
|
kobject_put(ecryptfs_kobj);
|
|
}
|
|
|
|
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.\n",
|
|
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\n");
|
|
goto out;
|
|
}
|
|
rc = register_filesystem(&ecryptfs_fs_type);
|
|
if (rc) {
|
|
printk(KERN_ERR "Failed to register filesystem\n");
|
|
goto out_free_kmem_caches;
|
|
}
|
|
rc = do_sysfs_registration();
|
|
if (rc) {
|
|
printk(KERN_ERR "sysfs registration failed\n");
|
|
goto out_unregister_filesystem;
|
|
}
|
|
rc = ecryptfs_init_kthread();
|
|
if (rc) {
|
|
printk(KERN_ERR "%s: kthread initialization failed; "
|
|
"rc = [%d]\n", __func__, rc);
|
|
goto out_do_sysfs_unregistration;
|
|
}
|
|
rc = ecryptfs_init_messaging();
|
|
if (rc) {
|
|
printk(KERN_ERR "Failure occured while attempting to "
|
|
"initialize the communications channel to "
|
|
"ecryptfsd\n");
|
|
goto out_destroy_kthread;
|
|
}
|
|
rc = ecryptfs_init_crypto();
|
|
if (rc) {
|
|
printk(KERN_ERR "Failure whilst attempting to init crypto; "
|
|
"rc = [%d]\n", rc);
|
|
goto out_release_messaging;
|
|
}
|
|
if (ecryptfs_verbosity > 0)
|
|
printk(KERN_CRIT "eCryptfs verbosity set to %d. Secret values "
|
|
"will be written to the syslog!\n", ecryptfs_verbosity);
|
|
|
|
goto out;
|
|
out_release_messaging:
|
|
ecryptfs_release_messaging();
|
|
out_destroy_kthread:
|
|
ecryptfs_destroy_kthread();
|
|
out_do_sysfs_unregistration:
|
|
do_sysfs_unregistration();
|
|
out_unregister_filesystem:
|
|
unregister_filesystem(&ecryptfs_fs_type);
|
|
out_free_kmem_caches:
|
|
ecryptfs_free_kmem_caches();
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
static void __exit ecryptfs_exit(void)
|
|
{
|
|
int rc;
|
|
|
|
rc = ecryptfs_destroy_crypto();
|
|
if (rc)
|
|
printk(KERN_ERR "Failure whilst attempting to destroy crypto; "
|
|
"rc = [%d]\n", rc);
|
|
ecryptfs_release_messaging();
|
|
ecryptfs_destroy_kthread();
|
|
do_sysfs_unregistration();
|
|
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)
|