2015-07-17 14:38:13 +00:00
|
|
|
/*
|
|
|
|
* (C) 2001 Clemson University and The University of Chicago
|
|
|
|
*
|
|
|
|
* See COPYING in top-level directory.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "protocol.h"
|
2015-12-04 17:56:14 +00:00
|
|
|
#include "orangefs-kernel.h"
|
2015-07-17 14:38:13 +00:00
|
|
|
|
|
|
|
/* tags assigned to kernel upcall operations */
|
|
|
|
static __u64 next_tag_value;
|
|
|
|
static DEFINE_SPINLOCK(next_tag_value_lock);
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
/* the orangefs memory caches */
|
2015-07-17 14:38:13 +00:00
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
/* a cache for orangefs upcall/downcall operations */
|
2015-07-17 14:38:13 +00:00
|
|
|
static struct kmem_cache *op_cache;
|
|
|
|
|
|
|
|
int op_cache_initialize(void)
|
|
|
|
{
|
2015-11-24 20:12:14 +00:00
|
|
|
op_cache = kmem_cache_create("orangefs_op_cache",
|
|
|
|
sizeof(struct orangefs_kernel_op_s),
|
2015-07-17 14:38:13 +00:00
|
|
|
0,
|
2015-11-24 20:12:14 +00:00
|
|
|
ORANGEFS_CACHE_CREATE_FLAGS,
|
2015-07-17 14:38:13 +00:00
|
|
|
NULL);
|
|
|
|
|
|
|
|
if (!op_cache) {
|
2015-11-24 20:12:14 +00:00
|
|
|
gossip_err("Cannot create orangefs_op_cache\n");
|
2015-07-17 14:38:13 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* initialize our atomic tag counter */
|
|
|
|
spin_lock(&next_tag_value_lock);
|
|
|
|
next_tag_value = 100;
|
|
|
|
spin_unlock(&next_tag_value_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int op_cache_finalize(void)
|
|
|
|
{
|
|
|
|
kmem_cache_destroy(op_cache);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
char *get_opname_string(struct orangefs_kernel_op_s *new_op)
|
2015-07-17 14:38:13 +00:00
|
|
|
{
|
|
|
|
if (new_op) {
|
|
|
|
__s32 type = new_op->upcall.type;
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
if (type == ORANGEFS_VFS_OP_FILE_IO)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_FILE_IO";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_LOOKUP)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_LOOKUP";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_CREATE)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_CREATE";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_GETATTR)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_GETATTR";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_REMOVE)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_REMOVE";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_MKDIR)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_MKDIR";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_READDIR)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_READDIR";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_READDIRPLUS)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_READDIRPLUS";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_SETATTR)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_SETATTR";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_SYMLINK)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_SYMLINK";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_RENAME)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_RENAME";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_STATFS)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_STATFS";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_TRUNCATE)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_TRUNCATE";
|
2016-08-02 18:31:05 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_RA_FLUSH)
|
|
|
|
return "OP_RA_FLUSH";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_FS_MOUNT)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_FS_MOUNT";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_FS_UMOUNT)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_FS_UMOUNT";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_GETXATTR)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_GETXATTR";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_SETXATTR)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_SETXATTR";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_LISTXATTR)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_LISTXATTR";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_REMOVEXATTR)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_REMOVEXATTR";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_PARAM)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_PARAM";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_PERF_COUNT)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_PERF_COUNT";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_CANCEL)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_CANCEL";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_FSYNC)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_FSYNC";
|
2015-11-24 20:12:14 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_FSKEY)
|
2015-07-17 14:38:13 +00:00
|
|
|
return "OP_FSKEY";
|
2016-08-12 16:02:31 +00:00
|
|
|
else if (type == ORANGEFS_VFS_OP_FEATURES)
|
|
|
|
return "OP_FEATURES";
|
2015-07-17 14:38:13 +00:00
|
|
|
}
|
|
|
|
return "OP_UNKNOWN?";
|
|
|
|
}
|
|
|
|
|
2016-02-12 04:07:19 +00:00
|
|
|
void orangefs_new_tag(struct orangefs_kernel_op_s *op)
|
|
|
|
{
|
|
|
|
spin_lock(&next_tag_value_lock);
|
|
|
|
op->tag = next_tag_value++;
|
|
|
|
if (next_tag_value == 0)
|
|
|
|
next_tag_value = 100;
|
|
|
|
spin_unlock(&next_tag_value_lock);
|
|
|
|
}
|
|
|
|
|
2015-11-24 20:12:14 +00:00
|
|
|
struct orangefs_kernel_op_s *op_alloc(__s32 type)
|
2015-07-17 14:38:13 +00:00
|
|
|
{
|
2015-11-24 20:12:14 +00:00
|
|
|
struct orangefs_kernel_op_s *new_op = NULL;
|
2015-07-17 14:38:13 +00:00
|
|
|
|
2016-02-04 18:48:16 +00:00
|
|
|
new_op = kmem_cache_zalloc(op_cache, GFP_KERNEL);
|
2015-07-17 14:38:13 +00:00
|
|
|
if (new_op) {
|
|
|
|
INIT_LIST_HEAD(&new_op->list);
|
|
|
|
spin_lock_init(&new_op->lock);
|
2016-02-13 15:15:22 +00:00
|
|
|
init_completion(&new_op->waitq);
|
2015-07-17 14:38:13 +00:00
|
|
|
|
2016-01-23 19:04:31 +00:00
|
|
|
new_op->upcall.type = ORANGEFS_VFS_OP_INVALID;
|
|
|
|
new_op->downcall.type = ORANGEFS_VFS_OP_INVALID;
|
|
|
|
new_op->downcall.status = -1;
|
|
|
|
|
|
|
|
new_op->op_state = OP_VFS_STATE_UNKNOWN;
|
2015-07-17 14:38:13 +00:00
|
|
|
|
|
|
|
/* initialize the op specific tag and upcall credentials */
|
2016-02-12 04:07:19 +00:00
|
|
|
orangefs_new_tag(new_op);
|
2015-07-17 14:38:13 +00:00
|
|
|
new_op->upcall.type = type;
|
|
|
|
new_op->attempts = 0;
|
|
|
|
gossip_debug(GOSSIP_CACHE_DEBUG,
|
|
|
|
"Alloced OP (%p: %llu %s)\n",
|
|
|
|
new_op,
|
|
|
|
llu(new_op->tag),
|
|
|
|
get_opname_string(new_op));
|
|
|
|
|
orangefs: fix namespace handling
In orangefs_inode_getxattr(), an fsuid is written to dmesg. The kuid is
converted to a userspace uid via from_kuid(current_user_ns(), [...]), but
since dmesg is global, init_user_ns should be used here instead.
In copy_attributes_from_inode(), op_alloc() and fill_default_sys_attrs(),
upcall structures are populated with uids/gids that have been mapped into
the caller's namespace. However, those upcall structures are read by
another process (the userspace filesystem driver), and that process might
be running in another namespace. This effectively lets any user spoof its
uid and gid as seen by the userspace filesystem driver.
To fix the second issue, I just construct the opcall structures with
init_user_ns uids/gids and require the filesystem server to run in the
init namespace. Since orangefs is full of global state anyway (as the error
message in DUMP_DEVICE_ERROR explains, there can only be one userspace
orangefs filesystem driver at once), that shouldn't be a problem.
[
Why does orangefs even exist in the kernel if everything does upcalls into
userspace? What does orangefs do that couldn't be done with the FUSE
interface? If there is no good answer to those questions, I'd prefer to see
orangefs kicked out of the kernel. Can that be done for something that
shipped in a release?
According to commit f7ab093f74bf ("Orangefs: kernel client part 1"), they
even already have a FUSE daemon, and the only rational reason (apart from
"but most of our users report preferring to use our kernel module instead")
given for not wanting to use FUSE is one "in-the-works" feature that could
probably be integated into FUSE instead.
]
This patch has been compile-tested.
Signed-off-by: Jann Horn <jannh@google.com>
Signed-off-by: Mike Marshall <hubcap@omnibond.com>
2016-06-24 23:51:52 +00:00
|
|
|
new_op->upcall.uid = from_kuid(&init_user_ns,
|
2015-07-17 14:38:13 +00:00
|
|
|
current_fsuid());
|
|
|
|
|
orangefs: fix namespace handling
In orangefs_inode_getxattr(), an fsuid is written to dmesg. The kuid is
converted to a userspace uid via from_kuid(current_user_ns(), [...]), but
since dmesg is global, init_user_ns should be used here instead.
In copy_attributes_from_inode(), op_alloc() and fill_default_sys_attrs(),
upcall structures are populated with uids/gids that have been mapped into
the caller's namespace. However, those upcall structures are read by
another process (the userspace filesystem driver), and that process might
be running in another namespace. This effectively lets any user spoof its
uid and gid as seen by the userspace filesystem driver.
To fix the second issue, I just construct the opcall structures with
init_user_ns uids/gids and require the filesystem server to run in the
init namespace. Since orangefs is full of global state anyway (as the error
message in DUMP_DEVICE_ERROR explains, there can only be one userspace
orangefs filesystem driver at once), that shouldn't be a problem.
[
Why does orangefs even exist in the kernel if everything does upcalls into
userspace? What does orangefs do that couldn't be done with the FUSE
interface? If there is no good answer to those questions, I'd prefer to see
orangefs kicked out of the kernel. Can that be done for something that
shipped in a release?
According to commit f7ab093f74bf ("Orangefs: kernel client part 1"), they
even already have a FUSE daemon, and the only rational reason (apart from
"but most of our users report preferring to use our kernel module instead")
given for not wanting to use FUSE is one "in-the-works" feature that could
probably be integated into FUSE instead.
]
This patch has been compile-tested.
Signed-off-by: Jann Horn <jannh@google.com>
Signed-off-by: Mike Marshall <hubcap@omnibond.com>
2016-06-24 23:51:52 +00:00
|
|
|
new_op->upcall.gid = from_kgid(&init_user_ns,
|
2015-07-17 14:38:13 +00:00
|
|
|
current_fsgid());
|
|
|
|
} else {
|
2016-02-04 18:48:16 +00:00
|
|
|
gossip_err("op_alloc: kmem_cache_zalloc failed!\n");
|
2015-07-17 14:38:13 +00:00
|
|
|
}
|
|
|
|
return new_op;
|
|
|
|
}
|
|
|
|
|
2016-02-19 00:17:51 +00:00
|
|
|
void op_release(struct orangefs_kernel_op_s *orangefs_op)
|
2015-07-17 14:38:13 +00:00
|
|
|
{
|
2015-11-24 20:12:14 +00:00
|
|
|
if (orangefs_op) {
|
2015-07-17 14:38:13 +00:00
|
|
|
gossip_debug(GOSSIP_CACHE_DEBUG,
|
|
|
|
"Releasing OP (%p: %llu)\n",
|
2015-11-24 20:12:14 +00:00
|
|
|
orangefs_op,
|
|
|
|
llu(orangefs_op->tag));
|
|
|
|
kmem_cache_free(op_cache, orangefs_op);
|
2015-07-17 14:38:13 +00:00
|
|
|
} else {
|
|
|
|
gossip_err("NULL pointer in op_release\n");
|
|
|
|
}
|
|
|
|
}
|