2019-05-27 06:55:05 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2021-03-30 16:44:53 +00:00
|
|
|
/*
|
2006-10-04 09:16:22 +00:00
|
|
|
* eCryptfs: Linux filesystem encryption layer
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1997-2003 Erez Zadok
|
|
|
|
|
* Copyright (C) 2001-2003 Stony Brook University
|
2007-02-12 08:53:46 +00:00
|
|
|
* Copyright (C) 2004-2007 International Business Machines Corp.
|
2006-10-04 09:16:22 +00:00
|
|
|
* Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
|
|
|
|
|
* Michael C. Thompson <mcthomps@us.ibm.com>
|
2020-02-13 21:25:54 +00:00
|
|
|
* Tyler Hicks <code@tyhicks.com>
|
2006-10-04 09:16:22 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#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>
|
2006-12-08 10:36:31 +00:00
|
|
|
#include <linux/fs_stack.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
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>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2010-11-03 10:11:22 +00:00
|
|
|
#include <linux/magic.h>
|
2006-10-04 09:16:22 +00:00
|
|
|
#include "ecryptfs_kernel.h"
|
|
|
|
|
|
2021-03-30 16:44:53 +00:00
|
|
|
/*
|
2006-10-04 09:16:22 +00:00
|
|
|
* 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)");
|
|
|
|
|
|
2021-03-30 16:44:53 +00:00
|
|
|
/*
|
2008-10-16 05:02:51 +00:00
|
|
|
* Module parameter that defines the number of message buffer elements
|
2007-02-12 08:53:44 +00:00
|
|
|
*/
|
|
|
|
|
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");
|
|
|
|
|
|
2021-03-30 16:44:53 +00:00
|
|
|
/*
|
2007-02-12 08:53:44 +00:00
|
|
|
* Module parameter that defines the maximum guaranteed amount of time to wait
|
2008-10-16 05:02:51 +00:00
|
|
|
* for a response from ecryptfsd. The actual sleep time will be, more than
|
2007-02-12 08:53:44 +00:00
|
|
|
* likely, a small amount greater than this specified value, but only less if
|
2008-10-16 05:02:51 +00:00
|
|
|
* the message successfully arrives.
|
2007-02-12 08:53:44 +00:00
|
|
|
*/
|
|
|
|
|
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");
|
|
|
|
|
|
2021-03-30 16:44:53 +00:00
|
|
|
/*
|
2007-02-12 08:53:44 +00:00
|
|
|
* 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");
|
|
|
|
|
|
2006-10-04 09:16:22 +00:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-30 16:44:53 +00:00
|
|
|
/*
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
* ecryptfs_init_lower_file
|
2007-10-16 08:28:09 +00:00
|
|
|
* @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
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
* lower file struct and associates it with the eCryptfs
|
|
|
|
|
* inode. When all eCryptfs files associated with the inode are released, the
|
|
|
|
|
* file is closed.
|
2007-10-16 08:28:09 +00:00
|
|
|
*
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
* The lower file will be opened with read/write permissions, if
|
2007-10-16 08:28:09 +00:00
|
|
|
* possible. Otherwise, it is opened read-only.
|
|
|
|
|
*
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
* This function does nothing if a lower file is already
|
2007-10-16 08:28:09 +00:00
|
|
|
* associated with the eCryptfs inode.
|
|
|
|
|
*
|
|
|
|
|
* Returns zero on success; non-zero otherwise
|
|
|
|
|
*/
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
static int ecryptfs_init_lower_file(struct dentry *dentry,
|
|
|
|
|
struct file **lower_file)
|
2007-10-16 08:28:09 +00:00
|
|
|
{
|
2008-11-13 23:39:22 +00:00
|
|
|
const struct cred *cred = current_cred();
|
2022-08-04 17:24:00 +00:00
|
|
|
const struct path *path = ecryptfs_dentry_to_lower_path(dentry);
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
int rc;
|
|
|
|
|
|
2013-06-15 11:55:59 +00:00
|
|
|
rc = ecryptfs_privileged_open(lower_file, path->dentry, path->mnt,
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
cred);
|
|
|
|
|
if (rc) {
|
|
|
|
|
printk(KERN_ERR "Error opening lower file "
|
|
|
|
|
"for lower_dentry [0x%p] and lower_mnt [0x%p]; "
|
2013-06-15 11:55:59 +00:00
|
|
|
"rc = [%d]\n", path->dentry, path->mnt, rc);
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
(*lower_file) = NULL;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-24 08:49:02 +00:00
|
|
|
int ecryptfs_get_lower_file(struct dentry *dentry, struct inode *inode)
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
{
|
2011-05-24 08:49:02 +00:00
|
|
|
struct ecryptfs_inode_info *inode_info;
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
int count, rc = 0;
|
2007-10-16 08:28:09 +00:00
|
|
|
|
2011-05-24 08:49:02 +00:00
|
|
|
inode_info = ecryptfs_inode_to_private(inode);
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
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);
|
2007-10-16 08:28:09 +00:00
|
|
|
}
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
mutex_unlock(&inode_info->lower_file_mutex);
|
2007-10-16 08:28:09 +00:00
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
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)) {
|
2012-09-13 01:02:46 +00:00
|
|
|
filemap_write_and_wait(inode->i_mapping);
|
eCryptfs: Add reference counting to lower files
For any given lower inode, eCryptfs keeps only one lower file open and
multiplexes all eCryptfs file operations through that lower file. The
lower file was considered "persistent" and stayed open from the first
lookup through the lifetime of the inode.
This patch keeps the notion of a single, per-inode lower file, but adds
reference counting around the lower file so that it is closed when not
currently in use. If the reference count is at 0 when an operation (such
as open, create, etc.) needs to use the lower file, a new lower file is
opened. Since the file is no longer persistent, all references to the
term persistent file are changed to lower file.
Locking is added around the sections of code that opens the lower file
and assign the pointer in the inode info, as well as the code the fputs
the lower file when all eCryptfs users are done with it.
This patch is needed to fix issues, when mounted on top of the NFSv3
client, where the lower file is left silly renamed until the eCryptfs
inode is destroyed.
Signed-off-by: Tyler Hicks <tyhicks@linux.vnet.ibm.com>
2011-04-14 20:35:11 +00:00
|
|
|
fput(inode_info->lower_file);
|
|
|
|
|
inode_info->lower_file = NULL;
|
|
|
|
|
mutex_unlock(&inode_info->lower_file_mutex);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-06 09:38:34 +00:00
|
|
|
enum { ecryptfs_opt_sig, ecryptfs_opt_ecryptfs_sig,
|
|
|
|
|
ecryptfs_opt_cipher, ecryptfs_opt_ecryptfs_cipher,
|
|
|
|
|
ecryptfs_opt_ecryptfs_key_bytes,
|
[PATCH] eCryptfs: xattr flags and mount options
This patch set introduces the ability to store cryptographic metadata into an
lower file extended attribute rather than the lower file header region.
This patch set implements two new mount options:
ecryptfs_xattr_metadata
- When set, newly created files will have their cryptographic
metadata stored in the extended attribute region of the file rather
than the header.
When storing the data in the file header, there is a minimum of 8KB
reserved for the header information for each file, making each file at
least 12KB in size. This can take up a lot of extra disk space if the user
creates a lot of small files. By storing the data in the extended
attribute, each file will only occupy at least of 4KB of space.
As the eCryptfs metadata set becomes larger with new features such as
multi-key associations, most popular filesystems will not be able to store
all of the information in the xattr region in some cases due to space
constraints. However, the majority of users will only ever associate one
key per file, so most users will be okay with storing their data in the
xattr region.
This option should be used with caution. I want to emphasize that the
xattr must be maintained under all circumstances, or the file will be
rendered permanently unrecoverable. The last thing I want is for a user to
forget to set an xattr flag in a backup utility, only to later discover
that their backups are worthless.
ecryptfs_encrypted_view
- When set, this option causes eCryptfs to present applications a
view of encrypted files as if the cryptographic metadata were
stored in the file header, whether the metadata is actually stored
in the header or in the extended attributes.
No matter what eCryptfs winds up doing in the lower filesystem, I want
to preserve a baseline format compatibility for the encrypted files. As of
right now, the metadata may be in the file header or in an xattr. There is
no reason why the metadata could not be put in a separate file in future
versions.
Without the compatibility mode, backup utilities would have to know to
back up the metadata file along with the files. The semantics of eCryptfs
have always been that the lower files are self-contained units of encrypted
data, and the only additional information required to decrypt any given
eCryptfs file is the key. That is what has always been emphasized about
eCryptfs lower files, and that is what users expect. Providing the
encrypted view option will provide a way to userspace applications wherein
they can always get to the same old familiar eCryptfs encrypted files,
regardless of what eCryptfs winds up doing with the metadata behind the
scenes.
This patch:
Add extended attribute support to version bit vector, flags to indicate when
xattr or encrypted view modes are enabled, and support for the new mount
options.
Signed-off-by: Michael Halcrow <mhalcrow@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-12 08:53:45 +00:00
|
|
|
ecryptfs_opt_passthrough, ecryptfs_opt_xattr_metadata,
|
2009-01-06 22:42:01 +00:00
|
|
|
ecryptfs_opt_encrypted_view, ecryptfs_opt_fnek_sig,
|
|
|
|
|
ecryptfs_opt_fn_cipher, ecryptfs_opt_fn_cipher_key_bytes,
|
2010-10-06 16:31:32 +00:00
|
|
|
ecryptfs_opt_unlink_sigs, ecryptfs_opt_mount_auth_tok_only,
|
2011-07-22 15:14:15 +00:00
|
|
|
ecryptfs_opt_check_dev_ruid,
|
2010-10-06 16:31:32 +00:00
|
|
|
ecryptfs_opt_err };
|
2006-10-04 09:16:22 +00:00
|
|
|
|
2008-10-13 09:46:57 +00:00
|
|
|
static const match_table_t tokens = {
|
2006-10-04 09:16:22 +00:00
|
|
|
{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"},
|
[PATCH] eCryptfs: xattr flags and mount options
This patch set introduces the ability to store cryptographic metadata into an
lower file extended attribute rather than the lower file header region.
This patch set implements two new mount options:
ecryptfs_xattr_metadata
- When set, newly created files will have their cryptographic
metadata stored in the extended attribute region of the file rather
than the header.
When storing the data in the file header, there is a minimum of 8KB
reserved for the header information for each file, making each file at
least 12KB in size. This can take up a lot of extra disk space if the user
creates a lot of small files. By storing the data in the extended
attribute, each file will only occupy at least of 4KB of space.
As the eCryptfs metadata set becomes larger with new features such as
multi-key associations, most popular filesystems will not be able to store
all of the information in the xattr region in some cases due to space
constraints. However, the majority of users will only ever associate one
key per file, so most users will be okay with storing their data in the
xattr region.
This option should be used with caution. I want to emphasize that the
xattr must be maintained under all circumstances, or the file will be
rendered permanently unrecoverable. The last thing I want is for a user to
forget to set an xattr flag in a backup utility, only to later discover
that their backups are worthless.
ecryptfs_encrypted_view
- When set, this option causes eCryptfs to present applications a
view of encrypted files as if the cryptographic metadata were
stored in the file header, whether the metadata is actually stored
in the header or in the extended attributes.
No matter what eCryptfs winds up doing in the lower filesystem, I want
to preserve a baseline format compatibility for the encrypted files. As of
right now, the metadata may be in the file header or in an xattr. There is
no reason why the metadata could not be put in a separate file in future
versions.
Without the compatibility mode, backup utilities would have to know to
back up the metadata file along with the files. The semantics of eCryptfs
have always been that the lower files are self-contained units of encrypted
data, and the only additional information required to decrypt any given
eCryptfs file is the key. That is what has always been emphasized about
eCryptfs lower files, and that is what users expect. Providing the
encrypted view option will provide a way to userspace applications wherein
they can always get to the same old familiar eCryptfs encrypted files,
regardless of what eCryptfs winds up doing with the metadata behind the
scenes.
This patch:
Add extended attribute support to version bit vector, flags to indicate when
xattr or encrypted view modes are enabled, and support for the new mount
options.
Signed-off-by: Michael Halcrow <mhalcrow@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-12 08:53:45 +00:00
|
|
|
{ecryptfs_opt_xattr_metadata, "ecryptfs_xattr_metadata"},
|
|
|
|
|
{ecryptfs_opt_encrypted_view, "ecryptfs_encrypted_view"},
|
2009-01-06 22:42:01 +00:00
|
|
|
{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"},
|
2009-04-22 09:08:46 +00:00
|
|
|
{ecryptfs_opt_unlink_sigs, "ecryptfs_unlink_sigs"},
|
2010-10-06 16:31:32 +00:00
|
|
|
{ecryptfs_opt_mount_auth_tok_only, "ecryptfs_mount_auth_tok_only"},
|
2011-07-22 15:14:15 +00:00
|
|
|
{ecryptfs_opt_check_dev_ruid, "ecryptfs_check_dev_ruid"},
|
2006-10-04 09:16:22 +00:00
|
|
|
{ecryptfs_opt_err, NULL}
|
|
|
|
|
};
|
|
|
|
|
|
2007-10-16 08:27:53 +00:00
|
|
|
static int ecryptfs_init_global_auth_toks(
|
|
|
|
|
struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
|
2006-10-04 09:16:22 +00:00
|
|
|
{
|
2007-10-16 08:27:53 +00:00
|
|
|
struct ecryptfs_global_auth_tok *global_auth_tok;
|
2011-03-21 15:00:53 +00:00
|
|
|
struct ecryptfs_auth_tok *auth_tok;
|
2006-10-04 09:16:22 +00:00
|
|
|
int rc = 0;
|
|
|
|
|
|
2007-10-16 08:27:53 +00:00
|
|
|
list_for_each_entry(global_auth_tok,
|
|
|
|
|
&mount_crypt_stat->global_auth_tok_list,
|
|
|
|
|
mount_crypt_stat_list) {
|
2007-10-16 08:28:06 +00:00
|
|
|
rc = ecryptfs_keyring_auth_tok_for_sig(
|
2011-03-21 15:00:53 +00:00
|
|
|
&global_auth_tok->global_auth_tok_key, &auth_tok,
|
2007-10-16 08:28:06 +00:00
|
|
|
global_auth_tok->sig);
|
|
|
|
|
if (rc) {
|
2007-10-16 08:27:53 +00:00
|
|
|
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;
|
2008-07-24 04:30:04 +00:00
|
|
|
goto out;
|
2011-03-21 15:00:55 +00:00
|
|
|
} else {
|
2007-10-16 08:27:53 +00:00
|
|
|
global_auth_tok->flags &= ~ECRYPTFS_AUTH_TOK_INVALID;
|
2011-03-21 15:00:55 +00:00
|
|
|
up_write(&(global_auth_tok->global_auth_tok_key)->sem);
|
|
|
|
|
}
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
2008-07-24 04:30:04 +00:00
|
|
|
out:
|
2006-10-04 09:16:22 +00:00
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-16 08:27:53 +00:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-04 09:16:22 +00:00
|
|
|
/**
|
|
|
|
|
* ecryptfs_parse_options
|
2021-03-30 16:44:53 +00:00
|
|
|
* @sbi: The ecryptfs super block
|
2011-03-31 01:57:33 +00:00
|
|
|
* @options: The options passed to the kernel
|
2011-07-22 15:14:15 +00:00
|
|
|
* @check_ruid: set to 1 if device uid should be checked against the ruid
|
2006-10-04 09:16:22 +00:00
|
|
|
*
|
|
|
|
|
* 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
|
|
|
|
|
*/
|
2011-07-22 15:14:15 +00:00
|
|
|
static int ecryptfs_parse_options(struct ecryptfs_sb_info *sbi, char *options,
|
|
|
|
|
uid_t *check_ruid)
|
2006-10-04 09:16:22 +00:00
|
|
|
{
|
|
|
|
|
char *p;
|
|
|
|
|
int rc = 0;
|
|
|
|
|
int sig_set = 0;
|
|
|
|
|
int cipher_name_set = 0;
|
2009-01-06 22:42:01 +00:00
|
|
|
int fn_cipher_name_set = 0;
|
2006-10-04 09:16:22 +00:00
|
|
|
int cipher_key_bytes;
|
|
|
|
|
int cipher_key_bytes_set = 0;
|
2009-01-06 22:42:01 +00:00
|
|
|
int fn_cipher_key_bytes;
|
|
|
|
|
int fn_cipher_key_bytes_set = 0;
|
2006-10-04 09:16:22 +00:00
|
|
|
struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
|
2010-03-21 16:24:29 +00:00
|
|
|
&sbi->mount_crypt_stat;
|
2006-10-04 09:16:22 +00:00
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
|
int token;
|
|
|
|
|
char *sig_src;
|
|
|
|
|
char *cipher_name_dst;
|
|
|
|
|
char *cipher_name_src;
|
2009-01-06 22:42:01 +00:00
|
|
|
char *fn_cipher_name_dst;
|
|
|
|
|
char *fn_cipher_name_src;
|
|
|
|
|
char *fnek_dst;
|
|
|
|
|
char *fnek_src;
|
2006-10-04 09:16:22 +00:00
|
|
|
char *cipher_key_bytes_src;
|
2009-01-06 22:42:01 +00:00
|
|
|
char *fn_cipher_key_bytes_src;
|
2012-07-12 23:10:24 +00:00
|
|
|
u8 cipher_code;
|
2006-10-04 09:16:22 +00:00
|
|
|
|
2011-07-22 15:14:15 +00:00
|
|
|
*check_ruid = 0;
|
|
|
|
|
|
2006-10-04 09:16:22 +00:00
|
|
|
if (!options) {
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2007-10-16 08:27:55 +00:00
|
|
|
ecryptfs_init_mount_crypt_stat(mount_crypt_stat);
|
2006-10-04 09:16:22 +00:00
|
|
|
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;
|
2007-10-16 08:27:53 +00:00
|
|
|
rc = ecryptfs_add_global_auth_tok(mount_crypt_stat,
|
2009-03-13 20:51:59 +00:00
|
|
|
sig_src, 0);
|
2007-10-16 08:27:53 +00:00
|
|
|
if (rc) {
|
|
|
|
|
printk(KERN_ERR "Error attempting to register "
|
|
|
|
|
"global sig; rc = [%d]\n", rc);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
2006-10-04 09:16:22 +00:00
|
|
|
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);
|
2009-01-06 22:42:01 +00:00
|
|
|
cipher_name_dst[ECRYPTFS_MAX_CIPHER_NAME_SIZE] = '\0';
|
2006-10-04 09:16:22 +00:00
|
|
|
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;
|
[PATCH] eCryptfs: xattr flags and mount options
This patch set introduces the ability to store cryptographic metadata into an
lower file extended attribute rather than the lower file header region.
This patch set implements two new mount options:
ecryptfs_xattr_metadata
- When set, newly created files will have their cryptographic
metadata stored in the extended attribute region of the file rather
than the header.
When storing the data in the file header, there is a minimum of 8KB
reserved for the header information for each file, making each file at
least 12KB in size. This can take up a lot of extra disk space if the user
creates a lot of small files. By storing the data in the extended
attribute, each file will only occupy at least of 4KB of space.
As the eCryptfs metadata set becomes larger with new features such as
multi-key associations, most popular filesystems will not be able to store
all of the information in the xattr region in some cases due to space
constraints. However, the majority of users will only ever associate one
key per file, so most users will be okay with storing their data in the
xattr region.
This option should be used with caution. I want to emphasize that the
xattr must be maintained under all circumstances, or the file will be
rendered permanently unrecoverable. The last thing I want is for a user to
forget to set an xattr flag in a backup utility, only to later discover
that their backups are worthless.
ecryptfs_encrypted_view
- When set, this option causes eCryptfs to present applications a
view of encrypted files as if the cryptographic metadata were
stored in the file header, whether the metadata is actually stored
in the header or in the extended attributes.
No matter what eCryptfs winds up doing in the lower filesystem, I want
to preserve a baseline format compatibility for the encrypted files. As of
right now, the metadata may be in the file header or in an xattr. There is
no reason why the metadata could not be put in a separate file in future
versions.
Without the compatibility mode, backup utilities would have to know to
back up the metadata file along with the files. The semantics of eCryptfs
have always been that the lower files are self-contained units of encrypted
data, and the only additional information required to decrypt any given
eCryptfs file is the key. That is what has always been emphasized about
eCryptfs lower files, and that is what users expect. Providing the
encrypted view option will provide a way to userspace applications wherein
they can always get to the same old familiar eCryptfs encrypted files,
regardless of what eCryptfs winds up doing with the metadata behind the
scenes.
This patch:
Add extended attribute support to version bit vector, flags to indicate when
xattr or encrypted view modes are enabled, and support for the new mount
options.
Signed-off-by: Michael Halcrow <mhalcrow@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-12 08:53:45 +00:00
|
|
|
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;
|
2009-01-06 22:42:01 +00:00
|
|
|
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,
|
2009-03-13 20:51:59 +00:00
|
|
|
mount_crypt_stat->global_default_fnek_sig,
|
|
|
|
|
ECRYPTFS_AUTH_TOK_FNEK);
|
2009-01-06 22:42:01 +00:00
|
|
|
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;
|
2009-04-22 09:08:46 +00:00
|
|
|
case ecryptfs_opt_unlink_sigs:
|
|
|
|
|
mount_crypt_stat->flags |= ECRYPTFS_UNLINK_SIGS;
|
|
|
|
|
break;
|
2010-10-06 16:31:32 +00:00
|
|
|
case ecryptfs_opt_mount_auth_tok_only:
|
|
|
|
|
mount_crypt_stat->flags |=
|
|
|
|
|
ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY;
|
|
|
|
|
break;
|
2011-07-22 15:14:15 +00:00
|
|
|
case ecryptfs_opt_check_dev_ruid:
|
|
|
|
|
*check_ruid = 1;
|
|
|
|
|
break;
|
2006-10-04 09:16:22 +00:00
|
|
|
case ecryptfs_opt_err:
|
|
|
|
|
default:
|
2009-01-06 22:42:01 +00:00
|
|
|
printk(KERN_WARNING
|
|
|
|
|
"%s: eCryptfs: unrecognized option [%s]\n",
|
|
|
|
|
__func__, p);
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!sig_set) {
|
|
|
|
|
rc = -EINVAL;
|
2007-10-16 08:27:55 +00:00
|
|
|
ecryptfs_printk(KERN_ERR, "You must supply at least one valid "
|
|
|
|
|
"auth tok signature as a mount "
|
2006-10-04 09:16:22 +00:00
|
|
|
"parameter; see the eCryptfs README\n");
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
if (!cipher_name_set) {
|
2008-07-24 04:30:05 +00:00
|
|
|
int cipher_name_len = strlen(ECRYPTFS_DEFAULT_CIPHER);
|
|
|
|
|
|
2015-02-23 11:34:10 +00:00
|
|
|
BUG_ON(cipher_name_len > ECRYPTFS_MAX_CIPHER_NAME_SIZE);
|
2008-07-24 04:30:05 +00:00
|
|
|
strcpy(mount_crypt_stat->global_default_cipher_name,
|
|
|
|
|
ECRYPTFS_DEFAULT_CIPHER);
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
2009-01-06 22:42:01 +00:00
|
|
|
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)
|
2006-10-31 06:07:16 +00:00
|
|
|
mount_crypt_stat->global_default_cipher_key_size = 0;
|
2009-01-06 22:42:01 +00:00
|
|
|
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;
|
2012-07-12 23:10:24 +00:00
|
|
|
|
|
|
|
|
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,
|
2016-09-27 12:18:02 +00:00
|
|
|
"eCryptfs doesn't support cipher: %s\n",
|
2012-07-12 23:10:24 +00:00
|
|
|
mount_crypt_stat->global_default_cipher_name);
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-06 09:38:37 +00:00
|
|
|
mutex_lock(&key_tfm_list_mutex);
|
|
|
|
|
if (!ecryptfs_tfm_exists(mount_crypt_stat->global_default_cipher_name,
|
2009-01-06 22:42:01 +00:00
|
|
|
NULL)) {
|
2008-02-06 09:38:37 +00:00
|
|
|
rc = ecryptfs_add_new_key_tfm(
|
|
|
|
|
NULL, mount_crypt_stat->global_default_cipher_name,
|
|
|
|
|
mount_crypt_stat->global_default_cipher_key_size);
|
2009-01-06 22:42:01 +00:00
|
|
|
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;
|
|
|
|
|
}
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
2009-01-06 22:42:01 +00:00
|
|
|
mutex_unlock(&key_tfm_list_mutex);
|
2007-10-16 08:28:06 +00:00
|
|
|
rc = ecryptfs_init_global_auth_toks(mount_crypt_stat);
|
2009-01-06 22:42:01 +00:00
|
|
|
if (rc)
|
2007-10-16 08:27:53 +00:00
|
|
|
printk(KERN_WARNING "One or more global auth toks could not "
|
|
|
|
|
"properly register; rc = [%d]\n", rc);
|
2006-10-04 09:16:22 +00:00
|
|
|
out:
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct kmem_cache *ecryptfs_sb_info_cache;
|
2010-05-17 04:59:46 +00:00
|
|
|
static struct file_system_type ecryptfs_fs_type;
|
2006-10-04 09:16:22 +00:00
|
|
|
|
2021-03-30 16:44:53 +00:00
|
|
|
/*
|
|
|
|
|
* ecryptfs_mount
|
|
|
|
|
* @fs_type: The filesystem type that the superblock should belong to
|
|
|
|
|
* @flags: The flags associated with the mount
|
2006-10-04 09:16:22 +00:00
|
|
|
* @dev_name: The path to mount over
|
|
|
|
|
* @raw_data: The options passed into the kernel
|
|
|
|
|
*/
|
2010-07-26 09:33:36 +00:00
|
|
|
static struct dentry *ecryptfs_mount(struct file_system_type *fs_type, int flags,
|
|
|
|
|
const char *dev_name, void *raw_data)
|
2006-10-04 09:16:22 +00:00
|
|
|
{
|
2010-03-21 16:24:29 +00:00
|
|
|
struct super_block *s;
|
|
|
|
|
struct ecryptfs_sb_info *sbi;
|
2014-10-07 20:51:55 +00:00
|
|
|
struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
|
2010-03-21 16:24:29 +00:00
|
|
|
struct ecryptfs_dentry_info *root_info;
|
|
|
|
|
const char *err = "Getting sb failed";
|
2011-01-13 01:04:37 +00:00
|
|
|
struct inode *inode;
|
|
|
|
|
struct path path;
|
2011-07-22 15:14:15 +00:00
|
|
|
uid_t check_ruid;
|
2006-10-04 09:16:22 +00:00
|
|
|
int rc;
|
|
|
|
|
|
2010-03-21 16:24:29 +00:00
|
|
|
sbi = kmem_cache_zalloc(ecryptfs_sb_info_cache, GFP_KERNEL);
|
|
|
|
|
if (!sbi) {
|
|
|
|
|
rc = -ENOMEM;
|
2006-10-04 09:16:22 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
2010-03-21 16:24:29 +00:00
|
|
|
|
2021-02-26 21:00:23 +00:00
|
|
|
if (!dev_name) {
|
|
|
|
|
rc = -EINVAL;
|
|
|
|
|
err = "Device name cannot be null";
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-22 15:14:15 +00:00
|
|
|
rc = ecryptfs_parse_options(sbi, raw_data, &check_ruid);
|
2006-10-04 09:16:22 +00:00
|
|
|
if (rc) {
|
2010-03-21 16:24:29 +00:00
|
|
|
err = "Error parsing options";
|
|
|
|
|
goto out;
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
2014-10-07 20:51:55 +00:00
|
|
|
mount_crypt_stat = &sbi->mount_crypt_stat;
|
2010-03-21 16:24:29 +00:00
|
|
|
|
2012-06-25 11:55:37 +00:00
|
|
|
s = sget(fs_type, NULL, set_anon_super, flags, NULL);
|
2010-03-21 16:24:29 +00:00
|
|
|
if (IS_ERR(s)) {
|
|
|
|
|
rc = PTR_ERR(s);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-12 10:24:35 +00:00
|
|
|
rc = super_setup_bdi(s);
|
2011-01-13 01:04:37 +00:00
|
|
|
if (rc)
|
|
|
|
|
goto out1;
|
2010-03-21 16:24:29 +00:00
|
|
|
|
|
|
|
|
ecryptfs_set_superblock_private(s, sbi);
|
|
|
|
|
|
|
|
|
|
/* ->kill_sb() will take care of sbi after that point */
|
|
|
|
|
sbi = NULL;
|
|
|
|
|
s->s_op = &ecryptfs_sops;
|
2016-09-29 15:48:36 +00:00
|
|
|
s->s_xattr = ecryptfs_xattr_handlers;
|
2011-01-13 01:04:37 +00:00
|
|
|
s->s_d_op = &ecryptfs_dops;
|
2010-03-21 16:24:29 +00:00
|
|
|
|
2011-01-13 01:04:37 +00:00
|
|
|
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;
|
|
|
|
|
}
|
2011-07-22 15:14:15 +00:00
|
|
|
|
2021-12-03 11:16:58 +00:00
|
|
|
if (is_idmapped_mnt(path.mnt)) {
|
2021-01-21 13:19:46 +00:00
|
|
|
rc = -EINVAL;
|
|
|
|
|
printk(KERN_ERR "Mounting on idmapped mounts currently disallowed\n");
|
|
|
|
|
goto out_free;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-17 22:25:59 +00:00
|
|
|
if (check_ruid && !uid_eq(d_inode(path.dentry)->i_uid, current_uid())) {
|
2011-07-22 15:14:15 +00:00
|
|
|
rc = -EPERM;
|
|
|
|
|
printk(KERN_ERR "Mount of device (uid: %d) not owned by "
|
|
|
|
|
"requested user (uid: %d)\n",
|
2015-03-17 22:25:59 +00:00
|
|
|
i_uid_read(d_inode(path.dentry)),
|
2012-02-08 00:24:33 +00:00
|
|
|
from_kuid(&init_user_ns, current_uid()));
|
2011-07-22 15:14:15 +00:00
|
|
|
goto out_free;
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-13 01:04:37 +00:00
|
|
|
ecryptfs_set_superblock_lower(s, path.dentry->d_sb);
|
2012-06-11 22:42:32 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Set the POSIX ACL flag based on whether they're enabled in the lower
|
2014-10-07 20:51:55 +00:00
|
|
|
* mount.
|
2012-06-11 22:42:32 +00:00
|
|
|
*/
|
2017-11-27 21:05:09 +00:00
|
|
|
s->s_flags = flags & ~SB_POSIXACL;
|
|
|
|
|
s->s_flags |= path.dentry->d_sb->s_flags & SB_POSIXACL;
|
2014-10-07 20:51:55 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Force a read-only eCryptfs mount when:
|
|
|
|
|
* 1) The lower mount is ro
|
|
|
|
|
* 2) The ecryptfs_encrypted_view mount option is specified
|
|
|
|
|
*/
|
2017-07-17 07:45:34 +00:00
|
|
|
if (sb_rdonly(path.dentry->d_sb) || mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
|
2017-11-27 21:05:09 +00:00
|
|
|
s->s_flags |= SB_RDONLY;
|
2012-06-11 22:42:32 +00:00
|
|
|
|
2011-01-13 01:04:37 +00:00
|
|
|
s->s_maxbytes = path.dentry->d_sb->s_maxbytes;
|
|
|
|
|
s->s_blocksize = path.dentry->d_sb->s_blocksize;
|
2010-11-03 10:11:22 +00:00
|
|
|
s->s_magic = ECRYPTFS_SUPER_MAGIC;
|
2014-10-23 22:14:39 +00:00
|
|
|
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;
|
|
|
|
|
}
|
2011-01-13 01:04:37 +00:00
|
|
|
|
2015-03-17 22:25:59 +00:00
|
|
|
inode = ecryptfs_get_inode(d_inode(path.dentry), s);
|
2011-01-13 01:04:37 +00:00
|
|
|
rc = PTR_ERR(inode);
|
|
|
|
|
if (IS_ERR(inode))
|
|
|
|
|
goto out_free;
|
|
|
|
|
|
2012-01-09 03:15:13 +00:00
|
|
|
s->s_root = d_make_root(inode);
|
2010-03-21 16:24:29 +00:00
|
|
|
if (!s->s_root) {
|
2011-01-13 01:04:37 +00:00
|
|
|
rc = -ENOMEM;
|
|
|
|
|
goto out_free;
|
2010-03-21 16:24:29 +00:00
|
|
|
}
|
|
|
|
|
|
2011-01-13 01:04:37 +00:00
|
|
|
rc = -ENOMEM;
|
2010-03-21 16:24:29 +00:00
|
|
|
root_info = kmem_cache_zalloc(ecryptfs_dentry_info_cache, GFP_KERNEL);
|
2011-01-13 01:04:37 +00:00
|
|
|
if (!root_info)
|
|
|
|
|
goto out_free;
|
|
|
|
|
|
2010-03-21 16:24:29 +00:00
|
|
|
/* ->kill_sb() will take care of root_info */
|
|
|
|
|
ecryptfs_set_dentry_private(s->s_root, root_info);
|
2013-09-16 00:50:13 +00:00
|
|
|
root_info->lower_path = path;
|
2011-01-13 01:04:37 +00:00
|
|
|
|
2017-11-27 21:05:09 +00:00
|
|
|
s->s_flags |= SB_ACTIVE;
|
2010-07-26 09:33:36 +00:00
|
|
|
return dget(s->s_root);
|
2010-03-21 16:24:29 +00:00
|
|
|
|
2011-01-13 01:04:37 +00:00
|
|
|
out_free:
|
|
|
|
|
path_put(&path);
|
|
|
|
|
out1:
|
|
|
|
|
deactivate_locked_super(s);
|
2006-10-04 09:16:22 +00:00
|
|
|
out:
|
2010-03-21 16:24:29 +00:00
|
|
|
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);
|
2010-07-26 09:33:36 +00:00
|
|
|
return ERR_PTR(rc);
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* 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)
|
|
|
|
|
{
|
2010-03-21 02:32:26 +00:00
|
|
|
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);
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct file_system_type ecryptfs_fs_type = {
|
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
|
.name = "ecryptfs",
|
2010-07-26 09:33:36 +00:00
|
|
|
.mount = ecryptfs_mount,
|
2006-10-04 09:16:22 +00:00
|
|
|
.kill_sb = ecryptfs_kill_block_super,
|
|
|
|
|
.fs_flags = 0
|
|
|
|
|
};
|
2013-03-03 03:39:14 +00:00
|
|
|
MODULE_ALIAS_FS("ecryptfs");
|
2006-10-04 09:16:22 +00:00
|
|
|
|
2021-03-30 16:44:53 +00:00
|
|
|
/*
|
2006-10-04 09:16:22 +00:00
|
|
|
* inode_info_init_once
|
|
|
|
|
*
|
|
|
|
|
* Initializes the ecryptfs_inode_info_cache when it is created
|
|
|
|
|
*/
|
|
|
|
|
static void
|
2008-07-26 02:45:34 +00:00
|
|
|
inode_info_init_once(void *vptr)
|
2006-10-04 09:16:22 +00:00
|
|
|
{
|
|
|
|
|
struct ecryptfs_inode_info *ei = (struct ecryptfs_inode_info *)vptr;
|
|
|
|
|
|
2007-05-17 05:10:57 +00:00
|
|
|
inode_init_once(&ei->vfs_inode);
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct ecryptfs_cache_info {
|
2006-12-07 04:33:20 +00:00
|
|
|
struct kmem_cache **cache;
|
2006-10-04 09:16:22 +00:00
|
|
|
const char *name;
|
|
|
|
|
size_t size;
|
2017-11-16 01:32:18 +00:00
|
|
|
slab_flags_t flags;
|
2008-07-26 02:45:34 +00:00
|
|
|
void (*ctor)(void *obj);
|
2006-10-04 09:16:22 +00:00
|
|
|
} 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),
|
2016-01-14 23:18:21 +00:00
|
|
|
.flags = SLAB_ACCOUNT,
|
2006-10-04 09:16:22 +00:00
|
|
|
.ctor = inode_info_init_once,
|
|
|
|
|
},
|
|
|
|
|
{
|
|
|
|
|
.cache = &ecryptfs_sb_info_cache,
|
|
|
|
|
.name = "ecryptfs_sb_cache",
|
|
|
|
|
.size = sizeof(struct ecryptfs_sb_info),
|
|
|
|
|
},
|
|
|
|
|
{
|
2011-05-24 10:11:12 +00:00
|
|
|
.cache = &ecryptfs_header_cache,
|
|
|
|
|
.name = "ecryptfs_headers",
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
.size = PAGE_SIZE,
|
2006-10-04 09:16:22 +00:00
|
|
|
},
|
2007-02-12 08:53:46 +00:00
|
|
|
{
|
|
|
|
|
.cache = &ecryptfs_xattr_cache,
|
|
|
|
|
.name = "ecryptfs_xattr_cache",
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
.size = PAGE_SIZE,
|
2007-02-12 08:53:46 +00:00
|
|
|
},
|
2007-02-16 09:28:40 +00:00
|
|
|
{
|
|
|
|
|
.cache = &ecryptfs_key_record_cache,
|
|
|
|
|
.name = "ecryptfs_key_record_cache",
|
|
|
|
|
.size = sizeof(struct ecryptfs_key_record),
|
|
|
|
|
},
|
2007-10-16 08:27:55 +00:00
|
|
|
{
|
|
|
|
|
.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),
|
|
|
|
|
},
|
2006-10-04 09:16:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void ecryptfs_free_kmem_caches(void)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2012-09-26 01:33:07 +00:00
|
|
|
/*
|
|
|
|
|
* Make sure all delayed rcu free inodes are flushed before we
|
|
|
|
|
* destroy cache.
|
|
|
|
|
*/
|
|
|
|
|
rcu_barrier();
|
|
|
|
|
|
2006-10-04 09:16:22 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(ecryptfs_cache_infos); i++) {
|
|
|
|
|
struct ecryptfs_cache_info *info;
|
|
|
|
|
|
|
|
|
|
info = &ecryptfs_cache_infos[i];
|
2015-09-13 12:15:21 +00:00
|
|
|
kmem_cache_destroy(*(info->cache));
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* 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];
|
2016-01-14 23:18:21 +00:00
|
|
|
*(info->cache) = kmem_cache_create(info->name, info->size, 0,
|
|
|
|
|
SLAB_HWCACHE_ALIGN | info->flags, info->ctor);
|
2006-10-04 09:16:22 +00:00
|
|
|
if (!*(info->cache)) {
|
|
|
|
|
ecryptfs_free_kmem_caches();
|
|
|
|
|
ecryptfs_printk(KERN_WARNING, "%s: "
|
|
|
|
|
"kmem_cache_create failed\n",
|
|
|
|
|
info->name);
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-06 23:08:08 +00:00
|
|
|
static struct kobject *ecryptfs_kobj;
|
2006-10-04 09:16:22 +00:00
|
|
|
|
2007-11-02 12:47:53 +00:00
|
|
|
static ssize_t version_show(struct kobject *kobj,
|
|
|
|
|
struct kobj_attribute *attr, char *buff)
|
2006-10-04 09:16:22 +00:00
|
|
|
{
|
|
|
|
|
return snprintf(buff, PAGE_SIZE, "%d\n", ECRYPTFS_VERSIONING_MASK);
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-02 12:47:53 +00:00
|
|
|
static struct kobj_attribute version_attr = __ATTR_RO(version);
|
2006-10-04 09:16:22 +00:00
|
|
|
|
2007-10-15 22:01:24 +00:00
|
|
|
static struct attribute *attributes[] = {
|
|
|
|
|
&version_attr.attr,
|
|
|
|
|
NULL,
|
|
|
|
|
};
|
|
|
|
|
|
2017-06-30 09:33:23 +00:00
|
|
|
static const struct attribute_group attr_group = {
|
2007-10-15 22:01:24 +00:00
|
|
|
.attrs = attributes,
|
|
|
|
|
};
|
2006-10-04 09:16:22 +00:00
|
|
|
|
|
|
|
|
static int do_sysfs_registration(void)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
|
2007-11-06 23:08:08 +00:00
|
|
|
ecryptfs_kobj = kobject_create_and_add("ecryptfs", fs_kobj);
|
|
|
|
|
if (!ecryptfs_kobj) {
|
2007-10-29 19:13:17 +00:00
|
|
|
printk(KERN_ERR "Unable to create ecryptfs kset\n");
|
|
|
|
|
rc = -ENOMEM;
|
2006-10-04 09:16:22 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
2007-11-06 23:08:08 +00:00
|
|
|
rc = sysfs_create_group(ecryptfs_kobj, &attr_group);
|
2006-10-04 09:16:22 +00:00
|
|
|
if (rc) {
|
|
|
|
|
printk(KERN_ERR
|
2007-10-15 22:01:24 +00:00
|
|
|
"Unable to create ecryptfs version attributes\n");
|
2007-12-20 16:13:05 +00:00
|
|
|
kobject_put(ecryptfs_kobj);
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
|
|
|
|
out:
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2007-08-10 20:00:56 +00:00
|
|
|
static void do_sysfs_unregistration(void)
|
|
|
|
|
{
|
2007-11-06 23:08:08 +00:00
|
|
|
sysfs_remove_group(ecryptfs_kobj, &attr_group);
|
2007-12-20 16:13:05 +00:00
|
|
|
kobject_put(ecryptfs_kobj);
|
2007-08-10 20:00:56 +00:00
|
|
|
}
|
|
|
|
|
|
2006-10-04 09:16:22 +00:00
|
|
|
static int __init ecryptfs_init(void)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
if (ECRYPTFS_DEFAULT_EXTENT_SIZE > PAGE_SIZE) {
|
2006-10-04 09:16:22 +00:00
|
|
|
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 "
|
2010-11-10 23:46:16 +00:00
|
|
|
"default eCryptfs extent size is [%u] bytes; "
|
|
|
|
|
"the page size is [%lu] bytes.\n",
|
|
|
|
|
ECRYPTFS_DEFAULT_EXTENT_SIZE,
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
(unsigned long)PAGE_SIZE);
|
2006-10-04 09:16:22 +00:00
|
|
|
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");
|
2012-03-18 01:29:13 +00:00
|
|
|
goto out_free_kmem_caches;
|
2006-10-04 09:16:22 +00:00
|
|
|
}
|
2008-07-24 04:30:02 +00:00
|
|
|
rc = ecryptfs_init_kthread();
|
|
|
|
|
if (rc) {
|
|
|
|
|
printk(KERN_ERR "%s: kthread initialization failed; "
|
|
|
|
|
"rc = [%d]\n", __func__, rc);
|
|
|
|
|
goto out_do_sysfs_unregistration;
|
|
|
|
|
}
|
2008-10-16 05:02:51 +00:00
|
|
|
rc = ecryptfs_init_messaging();
|
2007-02-12 08:53:44 +00:00
|
|
|
if (rc) {
|
2011-03-31 01:57:33 +00:00
|
|
|
printk(KERN_ERR "Failure occurred while attempting to "
|
2008-10-16 05:02:51 +00:00
|
|
|
"initialize the communications channel to "
|
|
|
|
|
"ecryptfsd\n");
|
2008-07-24 04:30:02 +00:00
|
|
|
goto out_destroy_kthread;
|
2007-10-16 08:27:55 +00:00
|
|
|
}
|
|
|
|
|
rc = ecryptfs_init_crypto();
|
|
|
|
|
if (rc) {
|
|
|
|
|
printk(KERN_ERR "Failure whilst attempting to init crypto; "
|
|
|
|
|
"rc = [%d]\n", rc);
|
2007-10-16 08:28:07 +00:00
|
|
|
goto out_release_messaging;
|
2007-02-12 08:53:44 +00:00
|
|
|
}
|
2012-03-18 01:29:13 +00:00
|
|
|
rc = register_filesystem(&ecryptfs_fs_type);
|
|
|
|
|
if (rc) {
|
|
|
|
|
printk(KERN_ERR "Failed to register filesystem\n");
|
|
|
|
|
goto out_destroy_crypto;
|
|
|
|
|
}
|
2008-02-06 09:38:34 +00:00
|
|
|
if (ecryptfs_verbosity > 0)
|
|
|
|
|
printk(KERN_CRIT "eCryptfs verbosity set to %d. Secret values "
|
|
|
|
|
"will be written to the syslog!\n", ecryptfs_verbosity);
|
|
|
|
|
|
2007-10-16 08:28:07 +00:00
|
|
|
goto out;
|
2012-03-18 01:29:13 +00:00
|
|
|
out_destroy_crypto:
|
|
|
|
|
ecryptfs_destroy_crypto();
|
2007-10-16 08:28:07 +00:00
|
|
|
out_release_messaging:
|
2008-10-16 05:02:51 +00:00
|
|
|
ecryptfs_release_messaging();
|
2008-07-24 04:30:02 +00:00
|
|
|
out_destroy_kthread:
|
|
|
|
|
ecryptfs_destroy_kthread();
|
2007-10-16 08:28:07 +00:00
|
|
|
out_do_sysfs_unregistration:
|
|
|
|
|
do_sysfs_unregistration();
|
|
|
|
|
out_free_kmem_caches:
|
|
|
|
|
ecryptfs_free_kmem_caches();
|
2006-10-04 09:16:22 +00:00
|
|
|
out:
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __exit ecryptfs_exit(void)
|
|
|
|
|
{
|
2007-10-16 08:28:07 +00:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
rc = ecryptfs_destroy_crypto();
|
|
|
|
|
if (rc)
|
|
|
|
|
printk(KERN_ERR "Failure whilst attempting to destroy crypto; "
|
|
|
|
|
"rc = [%d]\n", rc);
|
2008-10-16 05:02:51 +00:00
|
|
|
ecryptfs_release_messaging();
|
2008-07-24 04:30:02 +00:00
|
|
|
ecryptfs_destroy_kthread();
|
2007-10-16 08:28:07 +00:00
|
|
|
do_sysfs_unregistration();
|
2006-10-04 09:16:22 +00:00
|
|
|
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)
|