2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* net/sunrpc/rpc_pipe.c
|
|
|
|
*
|
|
|
|
* Userland/kernel interface for rpcauth_gss.
|
|
|
|
* Code shamelessly plagiarized from fs/nfsd/nfsctl.c
|
2005-09-02 00:59:25 -06:00
|
|
|
* and fs/sysfs/inode.c
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/namei.h>
|
2007-06-07 20:44:34 -06:00
|
|
|
#include <linux/fsnotify.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/kernel.h>
|
2012-03-01 15:00:56 -07:00
|
|
|
#include <linux/rcupdate.h>
|
2013-12-05 05:34:44 -07:00
|
|
|
#include <linux/utsname.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/ioctls.h>
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
|
|
|
|
#include <linux/sunrpc/clnt.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/sunrpc/rpc_pipe_fs.h>
|
2009-08-09 13:14:30 -06:00
|
|
|
#include <linux/sunrpc/cache.h>
|
2011-12-26 05:39:04 -07:00
|
|
|
#include <linux/nsproxy.h>
|
2011-12-26 05:39:13 -07:00
|
|
|
#include <linux/notifier.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-12-26 05:39:04 -07:00
|
|
|
#include "netns.h"
|
2011-12-26 05:39:13 -07:00
|
|
|
#include "sunrpc.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-12-26 05:39:47 -07:00
|
|
|
#define RPCDBG_FACILITY RPCDBG_DEBUG
|
|
|
|
|
|
|
|
#define NET_NAME(net) ((net == &init_net) ? " (init_net)" : "")
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static struct file_system_type rpc_pipe_fs_type;
|
2013-11-14 05:25:17 -07:00
|
|
|
static const struct rpc_pipe_ops gssd_dummy_pipe_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-06 21:33:20 -07:00
|
|
|
static struct kmem_cache *rpc_inode_cachep __read_mostly;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define RPC_UPCALL_TIMEOUT (30*HZ)
|
|
|
|
|
2011-12-26 05:39:13 -07:00
|
|
|
static BLOCKING_NOTIFIER_HEAD(rpc_pipefs_notifier_list);
|
|
|
|
|
|
|
|
int rpc_pipefs_notifier_register(struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_cond_register(&rpc_pipefs_notifier_list, nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_register);
|
|
|
|
|
|
|
|
void rpc_pipefs_notifier_unregister(struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list, nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_unregister);
|
|
|
|
|
2012-02-27 11:05:54 -07:00
|
|
|
static void rpc_purge_list(wait_queue_head_t *waitq, struct list_head *head,
|
2006-02-01 10:18:44 -07:00
|
|
|
void (*destroy_msg)(struct rpc_pipe_msg *), int err)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct rpc_pipe_msg *msg;
|
|
|
|
|
2006-02-01 10:18:44 -07:00
|
|
|
if (list_empty(head))
|
|
|
|
return;
|
|
|
|
do {
|
2005-11-25 15:10:11 -07:00
|
|
|
msg = list_entry(head->next, struct rpc_pipe_msg, list);
|
2010-09-12 17:55:25 -06:00
|
|
|
list_del_init(&msg->list);
|
2005-04-16 16:20:36 -06:00
|
|
|
msg->errno = err;
|
2005-11-25 15:10:11 -07:00
|
|
|
destroy_msg(msg);
|
2006-02-01 10:18:44 -07:00
|
|
|
} while (!list_empty(head));
|
2012-06-11 08:03:42 -06:00
|
|
|
|
|
|
|
if (waitq)
|
|
|
|
wake_up(waitq);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-11-22 07:55:48 -07:00
|
|
|
rpc_timeout_upcall_queue(struct work_struct *work)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-02-01 10:18:44 -07:00
|
|
|
LIST_HEAD(free_list);
|
2011-12-26 05:43:32 -07:00
|
|
|
struct rpc_pipe *pipe =
|
|
|
|
container_of(work, struct rpc_pipe, queue_timeout.work);
|
2006-02-01 10:18:44 -07:00
|
|
|
void (*destroy_msg)(struct rpc_pipe_msg *);
|
2012-02-27 11:05:54 -07:00
|
|
|
struct dentry *dentry;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-12-26 05:43:32 -07:00
|
|
|
spin_lock(&pipe->lock);
|
|
|
|
destroy_msg = pipe->ops->destroy_msg;
|
|
|
|
if (pipe->nreaders == 0) {
|
|
|
|
list_splice_init(&pipe->pipe, &free_list);
|
|
|
|
pipe->pipelen = 0;
|
2006-02-01 10:18:44 -07:00
|
|
|
}
|
2012-02-27 11:05:54 -07:00
|
|
|
dentry = dget(pipe->dentry);
|
2011-12-26 05:43:32 -07:00
|
|
|
spin_unlock(&pipe->lock);
|
2015-03-17 16:26:16 -06:00
|
|
|
rpc_purge_list(dentry ? &RPC_I(d_inode(dentry))->waitq : NULL,
|
2012-06-11 08:03:42 -06:00
|
|
|
&free_list, destroy_msg, -ETIMEDOUT);
|
|
|
|
dput(dentry);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-09-22 19:50:10 -06:00
|
|
|
ssize_t rpc_pipe_generic_upcall(struct file *filp, struct rpc_pipe_msg *msg,
|
|
|
|
char __user *dst, size_t buflen)
|
|
|
|
{
|
|
|
|
char *data = (char *)msg->data + msg->copied;
|
|
|
|
size_t mlen = min(msg->len - msg->copied, buflen);
|
|
|
|
unsigned long left;
|
|
|
|
|
|
|
|
left = copy_to_user(dst, data, mlen);
|
|
|
|
if (left == mlen) {
|
|
|
|
msg->errno = -EFAULT;
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
mlen -= left;
|
|
|
|
msg->copied += mlen;
|
|
|
|
msg->errno = 0;
|
|
|
|
return mlen;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_pipe_generic_upcall);
|
|
|
|
|
2007-11-06 11:06:03 -07:00
|
|
|
/**
|
2010-02-14 23:35:47 -07:00
|
|
|
* rpc_queue_upcall - queue an upcall message to userspace
|
2012-05-13 11:35:40 -06:00
|
|
|
* @pipe: upcall pipe on which to queue given message
|
2007-11-06 11:06:03 -07:00
|
|
|
* @msg: message to queue
|
|
|
|
*
|
|
|
|
* Call with an @inode created by rpc_mkpipe() to queue an upcall.
|
|
|
|
* A userspace process may then later read the upcall by performing a
|
|
|
|
* read on an open file for this inode. It is up to the caller to
|
|
|
|
* initialize the fields of @msg (other than @msg->list) appropriately.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-12-26 05:43:49 -07:00
|
|
|
rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-10-27 20:12:46 -06:00
|
|
|
int res = -EPIPE;
|
2012-02-27 11:05:54 -07:00
|
|
|
struct dentry *dentry;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-12-26 05:43:41 -07:00
|
|
|
spin_lock(&pipe->lock);
|
|
|
|
if (pipe->nreaders) {
|
|
|
|
list_add_tail(&msg->list, &pipe->pipe);
|
|
|
|
pipe->pipelen += msg->len;
|
2005-10-27 20:12:46 -06:00
|
|
|
res = 0;
|
2011-12-26 05:43:41 -07:00
|
|
|
} else if (pipe->flags & RPC_PIPE_WAIT_FOR_OPEN) {
|
|
|
|
if (list_empty(&pipe->pipe))
|
2006-03-20 11:44:08 -07:00
|
|
|
queue_delayed_work(rpciod_workqueue,
|
2011-12-26 05:43:41 -07:00
|
|
|
&pipe->queue_timeout,
|
2005-04-16 16:20:36 -06:00
|
|
|
RPC_UPCALL_TIMEOUT);
|
2011-12-26 05:43:41 -07:00
|
|
|
list_add_tail(&msg->list, &pipe->pipe);
|
|
|
|
pipe->pipelen += msg->len;
|
2005-10-27 20:12:46 -06:00
|
|
|
res = 0;
|
|
|
|
}
|
2012-02-27 11:05:54 -07:00
|
|
|
dentry = dget(pipe->dentry);
|
2011-12-26 05:43:41 -07:00
|
|
|
spin_unlock(&pipe->lock);
|
2012-02-27 11:05:54 -07:00
|
|
|
if (dentry) {
|
2015-03-17 16:26:16 -06:00
|
|
|
wake_up(&RPC_I(d_inode(dentry))->waitq);
|
2012-02-27 11:05:54 -07:00
|
|
|
dput(dentry);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
2008-12-23 13:21:31 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_queue_upcall);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-10-27 20:12:46 -06:00
|
|
|
static inline void
|
|
|
|
rpc_inode_setowner(struct inode *inode, void *private)
|
|
|
|
{
|
|
|
|
RPC_I(inode)->private = private;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void
|
|
|
|
rpc_close_pipes(struct inode *inode)
|
|
|
|
{
|
2011-12-26 05:43:32 -07:00
|
|
|
struct rpc_pipe *pipe = RPC_I(inode)->pipe;
|
2008-12-23 14:09:47 -07:00
|
|
|
int need_release;
|
2012-01-10 05:12:38 -07:00
|
|
|
LIST_HEAD(free_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(inode);
|
2012-01-10 05:12:38 -07:00
|
|
|
spin_lock(&pipe->lock);
|
|
|
|
need_release = pipe->nreaders != 0 || pipe->nwriters != 0;
|
|
|
|
pipe->nreaders = 0;
|
|
|
|
list_splice_init(&pipe->in_upcall, &free_list);
|
|
|
|
list_splice_init(&pipe->pipe, &free_list);
|
|
|
|
pipe->pipelen = 0;
|
|
|
|
pipe->dentry = NULL;
|
|
|
|
spin_unlock(&pipe->lock);
|
2012-02-27 11:05:54 -07:00
|
|
|
rpc_purge_list(&RPC_I(inode)->waitq, &free_list, pipe->ops->destroy_msg, -EPIPE);
|
2012-01-10 05:12:38 -07:00
|
|
|
pipe->nwriters = 0;
|
|
|
|
if (need_release && pipe->ops->release_pipe)
|
|
|
|
pipe->ops->release_pipe(inode);
|
|
|
|
cancel_delayed_work_sync(&pipe->queue_timeout);
|
2005-10-27 20:12:46 -06:00
|
|
|
rpc_inode_setowner(inode, NULL);
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
RPC_I(inode)->pipe = NULL;
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct inode *
|
|
|
|
rpc_alloc_inode(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct rpc_inode *rpci;
|
2014-06-10 08:49:17 -06:00
|
|
|
rpci = kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!rpci)
|
|
|
|
return NULL;
|
|
|
|
return &rpci->vfs_inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-01-06 23:49:49 -07:00
|
|
|
rpc_i_callback(struct rcu_head *head)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-01-06 23:49:49 -07:00
|
|
|
struct inode *inode = container_of(head, struct inode, i_rcu);
|
2005-04-16 16:20:36 -06:00
|
|
|
kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
|
|
|
|
}
|
|
|
|
|
2011-01-06 23:49:49 -07:00
|
|
|
static void
|
|
|
|
rpc_destroy_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
call_rcu(&inode->i_rcu, rpc_i_callback);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int
|
|
|
|
rpc_pipe_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
struct rpc_pipe *pipe;
|
2008-12-23 14:08:32 -07:00
|
|
|
int first_open;
|
2005-04-16 16:20:36 -06:00
|
|
|
int res = -ENXIO;
|
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(inode);
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
pipe = RPC_I(inode)->pipe;
|
|
|
|
if (pipe == NULL)
|
2008-12-23 14:08:32 -07:00
|
|
|
goto out;
|
2011-12-26 05:43:41 -07:00
|
|
|
first_open = pipe->nreaders == 0 && pipe->nwriters == 0;
|
|
|
|
if (first_open && pipe->ops->open_pipe) {
|
|
|
|
res = pipe->ops->open_pipe(inode);
|
2008-12-23 14:08:32 -07:00
|
|
|
if (res)
|
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-12-23 14:08:32 -07:00
|
|
|
if (filp->f_mode & FMODE_READ)
|
2011-12-26 05:43:41 -07:00
|
|
|
pipe->nreaders++;
|
2008-12-23 14:08:32 -07:00
|
|
|
if (filp->f_mode & FMODE_WRITE)
|
2011-12-26 05:43:41 -07:00
|
|
|
pipe->nwriters++;
|
2008-12-23 14:08:32 -07:00
|
|
|
res = 0;
|
|
|
|
out:
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_pipe_release(struct inode *inode, struct file *filp)
|
|
|
|
{
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
struct rpc_pipe *pipe;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct rpc_pipe_msg *msg;
|
2008-12-23 14:09:47 -07:00
|
|
|
int last_close;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(inode);
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
pipe = RPC_I(inode)->pipe;
|
|
|
|
if (pipe == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
2010-09-04 19:52:53 -06:00
|
|
|
msg = filp->private_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (msg != NULL) {
|
2011-12-26 05:43:32 -07:00
|
|
|
spin_lock(&pipe->lock);
|
2005-12-19 15:11:22 -07:00
|
|
|
msg->errno = -EAGAIN;
|
2010-09-12 17:55:25 -06:00
|
|
|
list_del_init(&msg->list);
|
2011-12-26 05:43:32 -07:00
|
|
|
spin_unlock(&pipe->lock);
|
|
|
|
pipe->ops->destroy_msg(msg);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (filp->f_mode & FMODE_WRITE)
|
2011-12-26 05:43:32 -07:00
|
|
|
pipe->nwriters --;
|
2006-02-01 10:18:44 -07:00
|
|
|
if (filp->f_mode & FMODE_READ) {
|
2011-12-26 05:43:32 -07:00
|
|
|
pipe->nreaders --;
|
|
|
|
if (pipe->nreaders == 0) {
|
2006-02-01 10:18:44 -07:00
|
|
|
LIST_HEAD(free_list);
|
2011-12-26 05:43:32 -07:00
|
|
|
spin_lock(&pipe->lock);
|
|
|
|
list_splice_init(&pipe->pipe, &free_list);
|
|
|
|
pipe->pipelen = 0;
|
|
|
|
spin_unlock(&pipe->lock);
|
2012-02-27 11:05:54 -07:00
|
|
|
rpc_purge_list(&RPC_I(inode)->waitq, &free_list,
|
2011-12-26 05:43:32 -07:00
|
|
|
pipe->ops->destroy_msg, -EAGAIN);
|
2006-02-01 10:18:44 -07:00
|
|
|
}
|
|
|
|
}
|
2011-12-26 05:43:32 -07:00
|
|
|
last_close = pipe->nwriters == 0 && pipe->nreaders == 0;
|
|
|
|
if (last_close && pipe->ops->release_pipe)
|
|
|
|
pipe->ops->release_pipe(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
|
|
|
|
{
|
2013-01-23 15:07:38 -07:00
|
|
|
struct inode *inode = file_inode(filp);
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
struct rpc_pipe *pipe;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct rpc_pipe_msg *msg;
|
|
|
|
int res = 0;
|
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(inode);
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
pipe = RPC_I(inode)->pipe;
|
|
|
|
if (pipe == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
res = -EPIPE;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
msg = filp->private_data;
|
|
|
|
if (msg == NULL) {
|
2011-12-26 05:43:41 -07:00
|
|
|
spin_lock(&pipe->lock);
|
|
|
|
if (!list_empty(&pipe->pipe)) {
|
|
|
|
msg = list_entry(pipe->pipe.next,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct rpc_pipe_msg,
|
|
|
|
list);
|
2011-12-26 05:43:41 -07:00
|
|
|
list_move(&msg->list, &pipe->in_upcall);
|
|
|
|
pipe->pipelen -= msg->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
filp->private_data = msg;
|
|
|
|
msg->copied = 0;
|
|
|
|
}
|
2011-12-26 05:43:41 -07:00
|
|
|
spin_unlock(&pipe->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (msg == NULL)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
/* NOTE: it is up to the callback to update msg->copied */
|
2011-12-26 05:43:41 -07:00
|
|
|
res = pipe->ops->upcall(filp, msg, buf, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (res < 0 || msg->len == msg->copied) {
|
|
|
|
filp->private_data = NULL;
|
2011-12-26 05:43:41 -07:00
|
|
|
spin_lock(&pipe->lock);
|
2010-09-12 17:55:25 -06:00
|
|
|
list_del_init(&msg->list);
|
2011-12-26 05:43:41 -07:00
|
|
|
spin_unlock(&pipe->lock);
|
|
|
|
pipe->ops->destroy_msg(msg);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
out_unlock:
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
|
|
|
|
{
|
2013-01-23 15:07:38 -07:00
|
|
|
struct inode *inode = file_inode(filp);
|
2005-04-16 16:20:36 -06:00
|
|
|
int res;
|
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
res = -EPIPE;
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
if (RPC_I(inode)->pipe != NULL)
|
|
|
|
res = RPC_I(inode)->pipe->ops->downcall(filp, buf, len);
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-07-02 22:01:49 -06:00
|
|
|
static __poll_t
|
2005-04-16 16:20:36 -06:00
|
|
|
rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
|
|
|
|
{
|
2013-01-23 15:07:38 -07:00
|
|
|
struct inode *inode = file_inode(filp);
|
2012-02-27 11:05:54 -07:00
|
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
2018-02-11 15:34:03 -07:00
|
|
|
__poll_t mask = EPOLLOUT | EPOLLWRNORM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
poll_wait(filp, &rpci->waitq, wait);
|
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(inode);
|
2012-02-27 11:05:54 -07:00
|
|
|
if (rpci->pipe == NULL)
|
2018-02-11 15:34:03 -07:00
|
|
|
mask |= EPOLLERR | EPOLLHUP;
|
2012-02-27 11:05:54 -07:00
|
|
|
else if (filp->private_data || !list_empty(&rpci->pipe->pipe))
|
2018-02-11 15:34:03 -07:00
|
|
|
mask |= EPOLLIN | EPOLLRDNORM;
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
2010-10-04 13:18:23 -06:00
|
|
|
static long
|
|
|
|
rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-01-23 15:07:38 -07:00
|
|
|
struct inode *inode = file_inode(filp);
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
struct rpc_pipe *pipe;
|
2005-04-16 16:20:36 -06:00
|
|
|
int len;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case FIONREAD:
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(inode);
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
pipe = RPC_I(inode)->pipe;
|
|
|
|
if (pipe == NULL) {
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EPIPE;
|
2010-10-04 13:18:23 -06:00
|
|
|
}
|
SUNRPC: check RPC inode's pipe reference before dereferencing
There are 2 tightly bound objects: pipe data (created for kernel needs, has
reference to dentry, which depends on PipeFS mount/umount) and PipeFS
dentry/inode pair (created on mount for user-space needs). They both
independently may have or have not a valid reference to each other.
This means, that we have to make sure, that pipe->dentry reference is valid on
upcalls, and dentry->pipe reference is valid on downcalls. The latter check is
absent - my fault.
IOW, PipeFS dentry can be opened by some process (rpc.idmapd for example), but
it's pipe data can belong to NFS mount, which was unmounted already and thus
pipe data was destroyed.
To fix this, pipe reference have to be set to NULL on rpc_unlink() and checked
on PipeFS file operations instead of pipe->dentry check.
Note: PipeFS "poll" file operation will be updated in next patch, because it's
logic is more complicated.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2012-02-27 11:05:45 -07:00
|
|
|
spin_lock(&pipe->lock);
|
2011-12-26 05:43:41 -07:00
|
|
|
len = pipe->pipelen;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (filp->private_data) {
|
|
|
|
struct rpc_pipe_msg *msg;
|
2010-09-04 19:52:53 -06:00
|
|
|
msg = filp->private_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
len += msg->len - msg->copied;
|
|
|
|
}
|
2011-12-26 05:43:41 -07:00
|
|
|
spin_unlock(&pipe->lock);
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
return put_user(len, (int __user *)arg);
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:36 -07:00
|
|
|
static const struct file_operations rpc_pipe_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.llseek = no_llseek,
|
|
|
|
.read = rpc_pipe_read,
|
|
|
|
.write = rpc_pipe_write,
|
|
|
|
.poll = rpc_pipe_poll,
|
2010-05-19 07:08:17 -06:00
|
|
|
.unlocked_ioctl = rpc_pipe_ioctl,
|
2005-04-16 16:20:36 -06:00
|
|
|
.open = rpc_pipe_open,
|
|
|
|
.release = rpc_pipe_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_show_info(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt = m->private;
|
|
|
|
|
2012-03-01 15:00:56 -07:00
|
|
|
rcu_read_lock();
|
2012-03-01 15:01:05 -07:00
|
|
|
seq_printf(m, "RPC server: %s\n",
|
|
|
|
rcu_dereference(clnt->cl_xprt)->servername);
|
2013-08-23 09:48:15 -06:00
|
|
|
seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_program->name,
|
2005-04-16 16:20:36 -06:00
|
|
|
clnt->cl_prog, clnt->cl_vers);
|
2006-08-22 18:06:19 -06:00
|
|
|
seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
|
|
|
|
seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
|
2007-09-26 12:38:09 -06:00
|
|
|
seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
|
2012-03-01 15:00:56 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_info_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2010-09-12 17:55:25 -06:00
|
|
|
struct rpc_clnt *clnt = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
int ret = single_open(file, rpc_show_info, NULL);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
struct seq_file *m = file->private_data;
|
2010-09-12 17:55:25 -06:00
|
|
|
|
|
|
|
spin_lock(&file->f_path.dentry->d_lock);
|
|
|
|
if (!d_unhashed(file->f_path.dentry))
|
|
|
|
clnt = RPC_I(inode)->private;
|
|
|
|
if (clnt != NULL && atomic_inc_not_zero(&clnt->cl_count)) {
|
|
|
|
spin_unlock(&file->f_path.dentry->d_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
m->private = clnt;
|
|
|
|
} else {
|
2010-09-12 17:55:25 -06:00
|
|
|
spin_unlock(&file->f_path.dentry->d_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
single_release(inode, file);
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_info_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
|
|
|
|
|
|
|
|
if (clnt)
|
|
|
|
rpc_release_client(clnt);
|
|
|
|
return single_release(inode, file);
|
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:36 -07:00
|
|
|
static const struct file_operations rpc_info_operations = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = rpc_info_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = rpc_info_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Description of fs contents.
|
|
|
|
*/
|
|
|
|
struct rpc_filelist {
|
2009-08-09 13:14:20 -06:00
|
|
|
const char *name;
|
2006-03-28 02:56:41 -07:00
|
|
|
const struct file_operations *i_fop;
|
2009-08-09 13:14:16 -06:00
|
|
|
umode_t mode;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct inode *
|
2009-08-09 13:14:16 -06:00
|
|
|
rpc_get_inode(struct super_block *sb, umode_t mode)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct inode *inode = new_inode(sb);
|
|
|
|
if (!inode)
|
|
|
|
return NULL;
|
2010-10-23 09:19:54 -06:00
|
|
|
inode->i_ino = get_next_ino();
|
2005-04-16 16:20:36 -06:00
|
|
|
inode->i_mode = mode;
|
2016-09-14 08:48:04 -06:00
|
|
|
inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
|
2011-07-01 03:43:12 -06:00
|
|
|
switch (mode & S_IFMT) {
|
|
|
|
case S_IFDIR:
|
|
|
|
inode->i_fop = &simple_dir_operations;
|
2013-07-16 07:16:45 -06:00
|
|
|
inode->i_op = &simple_dir_inode_operations;
|
2011-07-01 03:43:12 -06:00
|
|
|
inc_nlink(inode);
|
|
|
|
default:
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:17 -06:00
|
|
|
static int __rpc_create_common(struct inode *dir, struct dentry *dentry,
|
|
|
|
umode_t mode,
|
|
|
|
const struct file_operations *i_fop,
|
|
|
|
void *private)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
|
kernel panic when mount NFSv4
On Tue, 2010-12-14 at 16:58 +0800, Mi Jinlong wrote:
> Hi,
>
> When testing NFSv4 at RHEL6 with kernel 2.6.32, I got a kernel panic
> at NFS client's __rpc_create_common function.
>
> The panic place is:
> rpc_mkpipe
> __rpc_lookup_create() <=== find pipefile *idmap*
> __rpc_mkpipe() <=== pipefile is *idmap*
> __rpc_create_common()
> ****** BUG_ON(!d_unhashed(dentry)); ****** *panic*
>
> It means that the dentry's d_flags have be set DCACHE_UNHASHED,
> but it should not be set here.
>
> Is someone known this bug? or give me some idea?
>
> A reproduce program is append, but it can't reproduce the bug every time.
> the export is: "/nfsroot *(rw,no_root_squash,fsid=0,insecure)"
>
> And the panic message is append.
>
> ============================================================================
> #!/bin/sh
>
> LOOPTOTAL=768
> LOOPCOUNT=0
> ret=0
>
> while [ $LOOPCOUNT -ne $LOOPTOTAL ]
> do
> ((LOOPCOUNT += 1))
> service nfs restart
> /usr/sbin/rpc.idmapd
> mount -t nfs4 127.0.0.1:/ /mnt|| return 1;
> ls -l /var/lib/nfs/rpc_pipefs/nfs/*/
> umount /mnt
> echo $LOOPCOUNT
> done
>
> ===============================================================================
> Code: af 60 01 00 00 89 fa 89 f0 e8 64 cf 89 f0 e8 5c 7c 64 cf 31 c0 8b 5c 24 10 8b
> 74 24 14 8b 7c 24 18 8b 6c 24 1c 83 c4 20 c3 <0f> 0b eb fc 8b 46 28 c7 44 24 08 20
> de ee f0 c7 44 24 04 56 ea
> EIP:[<f0ee92ea>] __rpc_create_common+0x8a/0xc0 [sunrpc] SS:ESP 0068:eccb5d28
> ---[ end trace 8f5606cd08928ed2]---
> Kernel panic - not syncing: Fatal exception
> Pid:7131, comm: mount.nfs4 Tainted: G D -------------------2.6.32 #1
> Call Trace:
> [<c080ad18>] ? panic+0x42/0xed
> [<c080e42c>] ? oops_end+0xbc/0xd0
> [<c040b090>] ? do_invalid_op+0x0/0x90
> [<c040b10f>] ? do_invalid_op+0x7f/0x90
> [<f0ee92ea>] ? __rpc_create_common+0x8a/0xc0[sunrpc]
> [<f0edc433>] ? rpc_free_task+0x33/0x70[sunrpc]
> [<f0ed6508>] ? prc_call_sync+0x48/0x60[sunrpc]
> [<f0ed656e>] ? rpc_ping+0x4e/0x60[sunrpc]
> [<f0ed6eaf>] ? rpc_create+0x38f/0x4f0[sunrpc]
> [<c080d80b>] ? error_code+0x73/0x78
> [<f0ee92ea>] ? __rpc_create_common+0x8a/0xc0[sunrpc]
> [<c0532bda>] ? d_lookup+0x2a/0x40
> [<f0ee94b1>] ? rpc_mkpipe+0x111/0x1b0[sunrpc]
> [<f10a59f4>] ? nfs_create_rpc_client+0xb4/0xf0[nfs]
> [<f10d6c6d>] ? nfs_fscache_get_client_cookie+0x1d/0x50[nfs]
> [<f10d3fcb>] ? nfs_idmap_new+0x7b/0x140[nfs]
> [<c05e76aa>] ? strlcpy+0x3a/0x60
> [<f10a60ca>] ? nfs4_set_client+0xea/0x2b0[nfs]
> [<f10a6d0c>] ? nfs4_create_server+0xac/0x1b0[nfs]
> [<c04f1400>] ? krealloc+0x40/0x50
> [<f10b0e8b>] ? nfs4_remote_get_sb+0x6b/0x250[nfs]
> [<c04f14ec>] ? kstrdup+0x3c/0x60
> [<c0520739>] ? vfs_kern_mount+0x69/0x170
> [<f10b1a3c>] ? nfs_do_root_mount+0x6c/0xa0[nfs]
> [<f10b1b47>] ? nfs4_try_mount+0x37/0xa0[nfs]
> [<f10afe6d>] ? nfs4_validate_text_mount_data+-x7d/0xf0[nfs]
> [<f10b1c42>] ? nfs4_get_sb+0x92/0x2f0
> [<c0520739>] ? vfs_kern_mount+0x69/0x170
> [<c05366d2>] ? get_fs_type+0x32/0xb0
> [<c052089f>] ? do_kern_mount+0x3f/0xe0
> [<c053954f>] ? do_mount+0x2ef/0x740
> [<c0537740>] ? copy_mount_options+0xb0/0x120
> [<c0539a0e>] ? sys_mount+0x6e/0xa0
Hi,
Does the following patch fix the problem?
Cheers
Trond
--------------------------
SUNRPC: Fix a BUG in __rpc_create_common
From: Trond Myklebust <Trond.Myklebust@netapp.com>
Mi Jinlong reports:
When testing NFSv4 at RHEL6 with kernel 2.6.32, I got a kernel panic
at NFS client's __rpc_create_common function.
The panic place is:
rpc_mkpipe
__rpc_lookup_create() <=== find pipefile *idmap*
__rpc_mkpipe() <=== pipefile is *idmap*
__rpc_create_common()
****** BUG_ON(!d_unhashed(dentry)); ****** *panic*
The test is wrong: we can find ourselves with a hashed negative dentry here
if the idmapper tried to look up the file before we got round to creating
it.
Just replace the BUG_ON() with a d_drop(dentry).
Reported-by: Mi Jinlong <mijinlong@cn.fujitsu.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2010-12-20 14:19:26 -07:00
|
|
|
d_drop(dentry);
|
2009-08-09 13:14:17 -06:00
|
|
|
inode = rpc_get_inode(dir->i_sb, mode);
|
|
|
|
if (!inode)
|
|
|
|
goto out_err;
|
|
|
|
inode->i_ino = iunique(dir->i_sb, 100);
|
|
|
|
if (i_fop)
|
|
|
|
inode->i_fop = i_fop;
|
|
|
|
if (private)
|
|
|
|
rpc_inode_setowner(inode, private);
|
|
|
|
d_add(dentry, inode);
|
|
|
|
return 0;
|
|
|
|
out_err:
|
2013-09-16 08:57:41 -06:00
|
|
|
printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %pd\n",
|
|
|
|
__FILE__, __func__, dentry);
|
2009-08-09 13:14:17 -06:00
|
|
|
dput(dentry);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:20 -06:00
|
|
|
static int __rpc_create(struct inode *dir, struct dentry *dentry,
|
|
|
|
umode_t mode,
|
|
|
|
const struct file_operations *i_fop,
|
|
|
|
void *private)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
fsnotify_create(dir, dentry);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:17 -06:00
|
|
|
static int __rpc_mkdir(struct inode *dir, struct dentry *dentry,
|
|
|
|
umode_t mode,
|
|
|
|
const struct file_operations *i_fop,
|
|
|
|
void *private)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
inc_nlink(dir);
|
|
|
|
fsnotify_mkdir(dir, dentry);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-26 05:43:32 -07:00
|
|
|
static void
|
|
|
|
init_pipe(struct rpc_pipe *pipe)
|
|
|
|
{
|
|
|
|
pipe->nreaders = 0;
|
|
|
|
pipe->nwriters = 0;
|
|
|
|
INIT_LIST_HEAD(&pipe->in_upcall);
|
|
|
|
INIT_LIST_HEAD(&pipe->in_downcall);
|
|
|
|
INIT_LIST_HEAD(&pipe->pipe);
|
|
|
|
pipe->pipelen = 0;
|
|
|
|
INIT_DELAYED_WORK(&pipe->queue_timeout,
|
|
|
|
rpc_timeout_upcall_queue);
|
|
|
|
pipe->ops = NULL;
|
|
|
|
spin_lock_init(&pipe->lock);
|
2011-12-26 05:44:06 -07:00
|
|
|
pipe->dentry = NULL;
|
|
|
|
}
|
2011-12-26 05:43:32 -07:00
|
|
|
|
2011-12-26 05:44:06 -07:00
|
|
|
void rpc_destroy_pipe_data(struct rpc_pipe *pipe)
|
|
|
|
{
|
|
|
|
kfree(pipe);
|
2011-12-26 05:43:32 -07:00
|
|
|
}
|
2011-12-26 05:44:06 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data);
|
2011-12-26 05:43:32 -07:00
|
|
|
|
2011-12-26 05:44:06 -07:00
|
|
|
struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags)
|
2009-08-09 13:14:17 -06:00
|
|
|
{
|
2011-12-26 05:43:32 -07:00
|
|
|
struct rpc_pipe *pipe;
|
2009-08-09 13:14:17 -06:00
|
|
|
|
2011-12-26 05:43:32 -07:00
|
|
|
pipe = kzalloc(sizeof(struct rpc_pipe), GFP_KERNEL);
|
|
|
|
if (!pipe)
|
2011-12-26 05:44:06 -07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2011-12-26 05:43:32 -07:00
|
|
|
init_pipe(pipe);
|
2011-12-26 05:44:06 -07:00
|
|
|
pipe->ops = ops;
|
|
|
|
pipe->flags = flags;
|
|
|
|
return pipe;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_mkpipe_data);
|
|
|
|
|
|
|
|
static int __rpc_mkpipe_dentry(struct inode *dir, struct dentry *dentry,
|
|
|
|
umode_t mode,
|
|
|
|
const struct file_operations *i_fop,
|
|
|
|
void *private,
|
|
|
|
struct rpc_pipe *pipe)
|
2009-08-09 13:14:17 -06:00
|
|
|
{
|
|
|
|
struct rpc_inode *rpci;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2015-03-17 16:26:16 -06:00
|
|
|
rpci = RPC_I(d_inode(dentry));
|
2009-08-09 13:14:17 -06:00
|
|
|
rpci->private = private;
|
2011-12-26 05:43:32 -07:00
|
|
|
rpci->pipe = pipe;
|
2009-08-09 13:14:17 -06:00
|
|
|
fsnotify_create(dir, dentry);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:20 -06:00
|
|
|
static int __rpc_rmdir(struct inode *dir, struct dentry *dentry)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dget(dentry);
|
|
|
|
ret = simple_rmdir(dir, dentry);
|
|
|
|
d_delete(dentry);
|
|
|
|
dput(dentry);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:18 -06:00
|
|
|
static int __rpc_unlink(struct inode *dir, struct dentry *dentry)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dget(dentry);
|
|
|
|
ret = simple_unlink(dir, dentry);
|
|
|
|
d_delete(dentry);
|
|
|
|
dput(dentry);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
|
|
|
|
{
|
2015-03-17 16:26:16 -06:00
|
|
|
struct inode *inode = d_inode(dentry);
|
2009-08-09 13:14:18 -06:00
|
|
|
|
|
|
|
rpc_close_pipes(inode);
|
|
|
|
return __rpc_unlink(dir, dentry);
|
|
|
|
}
|
|
|
|
|
2011-11-08 05:09:19 -07:00
|
|
|
static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
|
2013-07-14 07:09:57 -06:00
|
|
|
const char *name)
|
2009-08-09 13:14:20 -06:00
|
|
|
{
|
2013-07-14 07:09:57 -06:00
|
|
|
struct qstr q = QSTR_INIT(name, strlen(name));
|
|
|
|
struct dentry *dentry = d_hash_and_lookup(parent, &q);
|
2009-08-09 13:14:20 -06:00
|
|
|
if (!dentry) {
|
2013-07-14 07:09:57 -06:00
|
|
|
dentry = d_alloc(parent, &q);
|
2011-11-08 05:09:19 -07:00
|
|
|
if (!dentry)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2009-08-09 13:14:20 -06:00
|
|
|
}
|
2015-03-17 16:26:16 -06:00
|
|
|
if (d_really_is_negative(dentry))
|
2009-08-09 13:14:20 -06:00
|
|
|
return dentry;
|
|
|
|
dput(dentry);
|
|
|
|
return ERR_PTR(-EEXIST);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* FIXME: This probably has races.
|
|
|
|
*/
|
2009-08-09 13:14:20 -06:00
|
|
|
static void __rpc_depopulate(struct dentry *parent,
|
|
|
|
const struct rpc_filelist *files,
|
|
|
|
int start, int eof)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-03-17 16:26:16 -06:00
|
|
|
struct inode *dir = d_inode(parent);
|
2009-08-09 13:14:20 -06:00
|
|
|
struct dentry *dentry;
|
|
|
|
struct qstr name;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-08-09 13:14:20 -06:00
|
|
|
for (i = start; i < eof; i++) {
|
|
|
|
name.name = files[i].name;
|
|
|
|
name.len = strlen(files[i].name);
|
2013-07-14 07:09:57 -06:00
|
|
|
dentry = d_hash_and_lookup(parent, &name);
|
2009-08-09 13:14:20 -06:00
|
|
|
|
|
|
|
if (dentry == NULL)
|
2007-06-08 12:14:46 -06:00
|
|
|
continue;
|
2015-03-17 16:26:16 -06:00
|
|
|
if (d_really_is_negative(dentry))
|
2009-08-09 13:14:20 -06:00
|
|
|
goto next;
|
2015-03-17 16:26:16 -06:00
|
|
|
switch (d_inode(dentry)->i_mode & S_IFMT) {
|
2009-08-09 13:14:20 -06:00
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
case S_IFREG:
|
|
|
|
__rpc_unlink(dir, dentry);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2009-08-09 13:14:20 -06:00
|
|
|
case S_IFDIR:
|
|
|
|
__rpc_rmdir(dir, dentry);
|
|
|
|
}
|
|
|
|
next:
|
|
|
|
dput(dentry);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-08-09 13:14:20 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rpc_depopulate(struct dentry *parent,
|
|
|
|
const struct rpc_filelist *files,
|
|
|
|
int start, int eof)
|
|
|
|
{
|
2015-03-17 16:26:16 -06:00
|
|
|
struct inode *dir = d_inode(parent);
|
2009-08-09 13:14:20 -06:00
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock_nested(dir, I_MUTEX_CHILD);
|
2009-08-09 13:14:20 -06:00
|
|
|
__rpc_depopulate(parent, files, start, eof);
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(dir);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:20 -06:00
|
|
|
static int rpc_populate(struct dentry *parent,
|
|
|
|
const struct rpc_filelist *files,
|
|
|
|
int start, int eof,
|
|
|
|
void *private)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-03-17 16:26:16 -06:00
|
|
|
struct inode *dir = d_inode(parent);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct dentry *dentry;
|
2009-08-09 13:14:20 -06:00
|
|
|
int i, err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock(dir);
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = start; i < eof; i++) {
|
2013-07-14 07:09:57 -06:00
|
|
|
dentry = __rpc_lookup_create_exclusive(parent, files[i].name);
|
2009-08-09 13:14:20 -06:00
|
|
|
err = PTR_ERR(dentry);
|
|
|
|
if (IS_ERR(dentry))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_bad;
|
2009-08-09 13:14:20 -06:00
|
|
|
switch (files[i].mode & S_IFMT) {
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
case S_IFREG:
|
|
|
|
err = __rpc_create(dir, dentry,
|
|
|
|
files[i].mode,
|
|
|
|
files[i].i_fop,
|
|
|
|
private);
|
|
|
|
break;
|
|
|
|
case S_IFDIR:
|
|
|
|
err = __rpc_mkdir(dir, dentry,
|
|
|
|
files[i].mode,
|
|
|
|
NULL,
|
|
|
|
private);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-08-09 13:14:20 -06:00
|
|
|
if (err != 0)
|
|
|
|
goto out_bad;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(dir);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
out_bad:
|
2009-08-09 13:14:20 -06:00
|
|
|
__rpc_depopulate(parent, files, start, eof);
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(dir);
|
2013-09-16 08:57:41 -06:00
|
|
|
printk(KERN_WARNING "%s: %s failed to populate directory %pd\n",
|
|
|
|
__FILE__, __func__, parent);
|
2009-08-09 13:14:20 -06:00
|
|
|
return err;
|
2005-09-23 09:08:25 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-08-09 13:14:26 -06:00
|
|
|
static struct dentry *rpc_mkdir_populate(struct dentry *parent,
|
2013-07-14 06:43:54 -06:00
|
|
|
const char *name, umode_t mode, void *private,
|
2009-08-09 13:14:26 -06:00
|
|
|
int (*populate)(struct dentry *, void *), void *args_populate)
|
2005-09-23 09:08:25 -06:00
|
|
|
{
|
|
|
|
struct dentry *dentry;
|
2015-03-17 16:26:16 -06:00
|
|
|
struct inode *dir = d_inode(parent);
|
2005-09-23 09:08:25 -06:00
|
|
|
int error;
|
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock_nested(dir, I_MUTEX_PARENT);
|
2009-08-09 13:14:23 -06:00
|
|
|
dentry = __rpc_lookup_create_exclusive(parent, name);
|
2005-09-23 09:08:25 -06:00
|
|
|
if (IS_ERR(dentry))
|
2009-08-09 13:14:23 -06:00
|
|
|
goto out;
|
|
|
|
error = __rpc_mkdir(dir, dentry, mode, NULL, private);
|
2009-08-09 13:14:17 -06:00
|
|
|
if (error != 0)
|
|
|
|
goto out_err;
|
2009-08-09 13:14:26 -06:00
|
|
|
if (populate != NULL) {
|
|
|
|
error = populate(dentry, args_populate);
|
|
|
|
if (error)
|
|
|
|
goto err_rmdir;
|
|
|
|
}
|
2005-09-23 09:08:25 -06:00
|
|
|
out:
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(dir);
|
2006-07-29 15:37:40 -06:00
|
|
|
return dentry;
|
2009-08-09 13:14:20 -06:00
|
|
|
err_rmdir:
|
2005-09-23 09:08:25 -06:00
|
|
|
__rpc_rmdir(dir, dentry);
|
2009-08-09 13:14:17 -06:00
|
|
|
out_err:
|
2005-09-23 09:08:25 -06:00
|
|
|
dentry = ERR_PTR(error);
|
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:26 -06:00
|
|
|
static int rpc_rmdir_depopulate(struct dentry *dentry,
|
|
|
|
void (*depopulate)(struct dentry *))
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-07-31 15:17:18 -06:00
|
|
|
struct dentry *parent;
|
2005-09-23 09:08:25 -06:00
|
|
|
struct inode *dir;
|
|
|
|
int error;
|
2005-07-24 16:53:01 -06:00
|
|
|
|
2006-07-31 15:17:18 -06:00
|
|
|
parent = dget_parent(dentry);
|
2015-03-17 16:26:16 -06:00
|
|
|
dir = d_inode(parent);
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock_nested(dir, I_MUTEX_PARENT);
|
2009-08-09 13:14:26 -06:00
|
|
|
if (depopulate != NULL)
|
|
|
|
depopulate(dentry);
|
2005-09-23 09:08:25 -06:00
|
|
|
error = __rpc_rmdir(dir, dentry);
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(dir);
|
2006-07-31 15:17:18 -06:00
|
|
|
dput(parent);
|
2005-09-23 09:08:25 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-11-06 11:06:03 -07:00
|
|
|
/**
|
|
|
|
* rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
|
|
|
|
* @parent: dentry of directory to create new "pipe" in
|
|
|
|
* @name: name of pipe
|
|
|
|
* @private: private data to associate with the pipe, for the caller's use
|
2012-05-13 11:35:40 -06:00
|
|
|
* @pipe: &rpc_pipe containing input parameters
|
2007-11-06 11:06:03 -07:00
|
|
|
*
|
|
|
|
* Data is made available for userspace to read by calls to
|
|
|
|
* rpc_queue_upcall(). The actual reads will result in calls to
|
|
|
|
* @ops->upcall, which will be called with the file pointer,
|
|
|
|
* message, and userspace buffer to copy to.
|
|
|
|
*
|
|
|
|
* Writes can come at any time, and do not necessarily have to be
|
|
|
|
* responses to upcalls. They will result in calls to @msg->downcall.
|
|
|
|
*
|
|
|
|
* The @private argument passed here will be available to all these methods
|
2013-01-23 15:07:38 -07:00
|
|
|
* from the file pointer, via RPC_I(file_inode(file))->private.
|
2007-11-06 11:06:03 -07:00
|
|
|
*/
|
2011-12-26 05:44:06 -07:00
|
|
|
struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name,
|
|
|
|
void *private, struct rpc_pipe *pipe)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct dentry *dentry;
|
2015-03-17 16:26:16 -06:00
|
|
|
struct inode *dir = d_inode(parent);
|
2018-03-23 16:54:38 -06:00
|
|
|
umode_t umode = S_IFIFO | 0600;
|
2009-08-09 13:14:17 -06:00
|
|
|
int err;
|
2009-08-09 13:14:16 -06:00
|
|
|
|
2011-12-26 05:44:06 -07:00
|
|
|
if (pipe->ops->upcall == NULL)
|
2018-03-23 16:54:38 -06:00
|
|
|
umode &= ~0444;
|
2011-12-26 05:44:06 -07:00
|
|
|
if (pipe->ops->downcall == NULL)
|
2018-03-23 16:54:38 -06:00
|
|
|
umode &= ~0222;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock_nested(dir, I_MUTEX_PARENT);
|
2013-07-14 07:09:57 -06:00
|
|
|
dentry = __rpc_lookup_create_exclusive(parent, name);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (IS_ERR(dentry))
|
2009-08-09 13:14:20 -06:00
|
|
|
goto out;
|
2011-12-26 05:44:06 -07:00
|
|
|
err = __rpc_mkpipe_dentry(dir, dentry, umode, &rpc_pipe_fops,
|
|
|
|
private, pipe);
|
2009-08-09 13:14:17 -06:00
|
|
|
if (err)
|
|
|
|
goto out_err;
|
2005-09-23 09:08:25 -06:00
|
|
|
out:
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(dir);
|
2006-07-29 15:37:40 -06:00
|
|
|
return dentry;
|
2009-08-09 13:14:17 -06:00
|
|
|
out_err:
|
|
|
|
dentry = ERR_PTR(err);
|
2013-09-16 08:57:41 -06:00
|
|
|
printk(KERN_WARNING "%s: %s() failed to create pipe %pd/%s (errno = %d)\n",
|
|
|
|
__FILE__, __func__, parent, name,
|
2009-08-09 13:14:17 -06:00
|
|
|
err);
|
2005-09-23 09:08:25 -06:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-12-26 05:44:06 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-11-06 11:06:03 -07:00
|
|
|
/**
|
|
|
|
* rpc_unlink - remove a pipe
|
|
|
|
* @dentry: dentry for the pipe, as returned from rpc_mkpipe
|
|
|
|
*
|
|
|
|
* After this call, lookups will no longer find the pipe, and any
|
|
|
|
* attempts to read or write using preexisting opens of the pipe will
|
|
|
|
* return -EPIPE.
|
|
|
|
*/
|
2005-09-23 09:08:25 -06:00
|
|
|
int
|
2006-07-31 15:11:48 -06:00
|
|
|
rpc_unlink(struct dentry *dentry)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-07-31 15:11:48 -06:00
|
|
|
struct dentry *parent;
|
2005-09-23 09:08:25 -06:00
|
|
|
struct inode *dir;
|
2006-07-31 15:11:48 -06:00
|
|
|
int error = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-07-31 15:11:48 -06:00
|
|
|
parent = dget_parent(dentry);
|
2015-03-17 16:26:16 -06:00
|
|
|
dir = d_inode(parent);
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_lock_nested(dir, I_MUTEX_PARENT);
|
2009-08-09 13:14:18 -06:00
|
|
|
error = __rpc_rmpipe(dir, dentry);
|
2016-01-22 13:40:57 -07:00
|
|
|
inode_unlock(dir);
|
2006-07-31 15:11:48 -06:00
|
|
|
dput(parent);
|
2005-09-23 09:08:25 -06:00
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-12-23 13:21:31 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_unlink);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-26 13:38:11 -06:00
|
|
|
/**
|
|
|
|
* rpc_init_pipe_dir_head - initialise a struct rpc_pipe_dir_head
|
|
|
|
* @pdh: pointer to struct rpc_pipe_dir_head
|
|
|
|
*/
|
|
|
|
void rpc_init_pipe_dir_head(struct rpc_pipe_dir_head *pdh)
|
|
|
|
{
|
|
|
|
INIT_LIST_HEAD(&pdh->pdh_entries);
|
|
|
|
pdh->pdh_dentry = NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_head);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_init_pipe_dir_object - initialise a struct rpc_pipe_dir_object
|
|
|
|
* @pdo: pointer to struct rpc_pipe_dir_object
|
|
|
|
* @pdo_ops: pointer to const struct rpc_pipe_dir_object_ops
|
|
|
|
* @pdo_data: pointer to caller-defined data
|
|
|
|
*/
|
|
|
|
void rpc_init_pipe_dir_object(struct rpc_pipe_dir_object *pdo,
|
|
|
|
const struct rpc_pipe_dir_object_ops *pdo_ops,
|
|
|
|
void *pdo_data)
|
|
|
|
{
|
|
|
|
INIT_LIST_HEAD(&pdo->pdo_head);
|
|
|
|
pdo->pdo_ops = pdo_ops;
|
|
|
|
pdo->pdo_data = pdo_data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_object);
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_add_pipe_dir_object_locked(struct net *net,
|
|
|
|
struct rpc_pipe_dir_head *pdh,
|
|
|
|
struct rpc_pipe_dir_object *pdo)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (pdh->pdh_dentry)
|
|
|
|
ret = pdo->pdo_ops->create(pdh->pdh_dentry, pdo);
|
|
|
|
if (ret == 0)
|
|
|
|
list_add_tail(&pdo->pdo_head, &pdh->pdh_entries);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
rpc_remove_pipe_dir_object_locked(struct net *net,
|
|
|
|
struct rpc_pipe_dir_head *pdh,
|
|
|
|
struct rpc_pipe_dir_object *pdo)
|
|
|
|
{
|
|
|
|
if (pdh->pdh_dentry)
|
|
|
|
pdo->pdo_ops->destroy(pdh->pdh_dentry, pdo);
|
|
|
|
list_del_init(&pdo->pdo_head);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_add_pipe_dir_object - associate a rpc_pipe_dir_object to a directory
|
|
|
|
* @net: pointer to struct net
|
|
|
|
* @pdh: pointer to struct rpc_pipe_dir_head
|
|
|
|
* @pdo: pointer to struct rpc_pipe_dir_object
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
rpc_add_pipe_dir_object(struct net *net,
|
|
|
|
struct rpc_pipe_dir_head *pdh,
|
|
|
|
struct rpc_pipe_dir_object *pdo)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (list_empty(&pdo->pdo_head)) {
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
|
|
|
|
mutex_lock(&sn->pipefs_sb_lock);
|
|
|
|
ret = rpc_add_pipe_dir_object_locked(net, pdh, pdo);
|
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_add_pipe_dir_object);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_remove_pipe_dir_object - remove a rpc_pipe_dir_object from a directory
|
|
|
|
* @net: pointer to struct net
|
|
|
|
* @pdh: pointer to struct rpc_pipe_dir_head
|
|
|
|
* @pdo: pointer to struct rpc_pipe_dir_object
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
rpc_remove_pipe_dir_object(struct net *net,
|
|
|
|
struct rpc_pipe_dir_head *pdh,
|
|
|
|
struct rpc_pipe_dir_object *pdo)
|
|
|
|
{
|
|
|
|
if (!list_empty(&pdo->pdo_head)) {
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
|
|
|
|
mutex_lock(&sn->pipefs_sb_lock);
|
|
|
|
rpc_remove_pipe_dir_object_locked(net, pdh, pdo);
|
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_remove_pipe_dir_object);
|
|
|
|
|
2013-08-27 14:27:04 -06:00
|
|
|
/**
|
|
|
|
* rpc_find_or_alloc_pipe_dir_object
|
|
|
|
* @net: pointer to struct net
|
|
|
|
* @pdh: pointer to struct rpc_pipe_dir_head
|
|
|
|
* @match: match struct rpc_pipe_dir_object to data
|
|
|
|
* @alloc: allocate a new struct rpc_pipe_dir_object
|
|
|
|
* @data: user defined data for match() and alloc()
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct rpc_pipe_dir_object *
|
|
|
|
rpc_find_or_alloc_pipe_dir_object(struct net *net,
|
|
|
|
struct rpc_pipe_dir_head *pdh,
|
|
|
|
int (*match)(struct rpc_pipe_dir_object *, void *),
|
|
|
|
struct rpc_pipe_dir_object *(*alloc)(void *),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
struct rpc_pipe_dir_object *pdo;
|
|
|
|
|
|
|
|
mutex_lock(&sn->pipefs_sb_lock);
|
|
|
|
list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head) {
|
|
|
|
if (!match(pdo, data))
|
|
|
|
continue;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
pdo = alloc(data);
|
|
|
|
if (!pdo)
|
|
|
|
goto out;
|
|
|
|
rpc_add_pipe_dir_object_locked(net, pdh, pdo);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
|
|
|
return pdo;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_find_or_alloc_pipe_dir_object);
|
|
|
|
|
2013-08-26 13:38:11 -06:00
|
|
|
static void
|
|
|
|
rpc_create_pipe_dir_objects(struct rpc_pipe_dir_head *pdh)
|
|
|
|
{
|
|
|
|
struct rpc_pipe_dir_object *pdo;
|
|
|
|
struct dentry *dir = pdh->pdh_dentry;
|
|
|
|
|
|
|
|
list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head)
|
|
|
|
pdo->pdo_ops->create(dir, pdo);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
rpc_destroy_pipe_dir_objects(struct rpc_pipe_dir_head *pdh)
|
|
|
|
{
|
|
|
|
struct rpc_pipe_dir_object *pdo;
|
|
|
|
struct dentry *dir = pdh->pdh_dentry;
|
|
|
|
|
|
|
|
list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head)
|
|
|
|
pdo->pdo_ops->destroy(dir, pdo);
|
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:26 -06:00
|
|
|
enum {
|
|
|
|
RPCAUTH_info,
|
|
|
|
RPCAUTH_EOF
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct rpc_filelist authfiles[] = {
|
|
|
|
[RPCAUTH_info] = {
|
|
|
|
.name = "info",
|
|
|
|
.i_fop = &rpc_info_operations,
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFREG | 0400,
|
2009-08-09 13:14:26 -06:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int rpc_clntdir_populate(struct dentry *dentry, void *private)
|
|
|
|
{
|
|
|
|
return rpc_populate(dentry,
|
|
|
|
authfiles, RPCAUTH_info, RPCAUTH_EOF,
|
|
|
|
private);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rpc_clntdir_depopulate(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF);
|
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:23 -06:00
|
|
|
/**
|
|
|
|
* rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
|
2013-07-14 06:43:54 -06:00
|
|
|
* @dentry: the parent of new directory
|
|
|
|
* @name: the name of new directory
|
2009-08-09 13:14:23 -06:00
|
|
|
* @rpc_client: rpc client to associate with this directory
|
|
|
|
*
|
|
|
|
* This creates a directory at the given @path associated with
|
|
|
|
* @rpc_clnt, which will contain a file named "info" with some basic
|
|
|
|
* information about the client, together with any "pipes" that may
|
|
|
|
* later be created using rpc_mkpipe().
|
|
|
|
*/
|
2009-08-09 13:14:25 -06:00
|
|
|
struct dentry *rpc_create_client_dir(struct dentry *dentry,
|
2013-07-14 06:43:54 -06:00
|
|
|
const char *name,
|
2009-08-09 13:14:26 -06:00
|
|
|
struct rpc_clnt *rpc_client)
|
|
|
|
{
|
2013-08-26 13:38:11 -06:00
|
|
|
struct dentry *ret;
|
|
|
|
|
2018-03-23 16:54:38 -06:00
|
|
|
ret = rpc_mkdir_populate(dentry, name, 0555, NULL,
|
|
|
|
rpc_clntdir_populate, rpc_client);
|
2013-08-26 13:38:11 -06:00
|
|
|
if (!IS_ERR(ret)) {
|
|
|
|
rpc_client->cl_pipedir_objects.pdh_dentry = ret;
|
|
|
|
rpc_create_pipe_dir_objects(&rpc_client->cl_pipedir_objects);
|
|
|
|
}
|
|
|
|
return ret;
|
2009-08-09 13:14:26 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
|
2013-08-26 13:38:11 -06:00
|
|
|
* @rpc_client: rpc_client for the pipe
|
2009-08-09 13:14:26 -06:00
|
|
|
*/
|
2013-08-26 15:44:26 -06:00
|
|
|
int rpc_remove_client_dir(struct rpc_clnt *rpc_client)
|
2009-08-09 13:14:23 -06:00
|
|
|
{
|
2013-08-26 15:44:26 -06:00
|
|
|
struct dentry *dentry = rpc_client->cl_pipedir_objects.pdh_dentry;
|
|
|
|
|
|
|
|
if (dentry == NULL)
|
|
|
|
return 0;
|
|
|
|
rpc_destroy_pipe_dir_objects(&rpc_client->cl_pipedir_objects);
|
|
|
|
rpc_client->cl_pipedir_objects.pdh_dentry = NULL;
|
2009-08-09 13:14:26 -06:00
|
|
|
return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
|
2009-08-09 13:14:23 -06:00
|
|
|
}
|
|
|
|
|
2009-08-09 13:14:30 -06:00
|
|
|
static const struct rpc_filelist cache_pipefs_files[3] = {
|
|
|
|
[0] = {
|
|
|
|
.name = "channel",
|
|
|
|
.i_fop = &cache_file_operations_pipefs,
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFREG | 0600,
|
2009-08-09 13:14:30 -06:00
|
|
|
},
|
|
|
|
[1] = {
|
|
|
|
.name = "content",
|
|
|
|
.i_fop = &content_file_operations_pipefs,
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFREG | 0400,
|
2009-08-09 13:14:30 -06:00
|
|
|
},
|
|
|
|
[2] = {
|
|
|
|
.name = "flush",
|
|
|
|
.i_fop = &cache_flush_operations_pipefs,
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFREG | 0600,
|
2009-08-09 13:14:30 -06:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static int rpc_cachedir_populate(struct dentry *dentry, void *private)
|
|
|
|
{
|
|
|
|
return rpc_populate(dentry,
|
|
|
|
cache_pipefs_files, 0, 3,
|
|
|
|
private);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rpc_cachedir_depopulate(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
rpc_depopulate(dentry, cache_pipefs_files, 0, 3);
|
|
|
|
}
|
|
|
|
|
2013-07-14 06:43:54 -06:00
|
|
|
struct dentry *rpc_create_cache_dir(struct dentry *parent, const char *name,
|
2011-07-24 22:35:13 -06:00
|
|
|
umode_t umode, struct cache_detail *cd)
|
2009-08-09 13:14:30 -06:00
|
|
|
{
|
|
|
|
return rpc_mkdir_populate(parent, name, umode, NULL,
|
|
|
|
rpc_cachedir_populate, cd);
|
|
|
|
}
|
|
|
|
|
|
|
|
void rpc_remove_cache_dir(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* populate the filesystem
|
|
|
|
*/
|
2009-09-21 18:01:09 -06:00
|
|
|
static const struct super_operations s_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.alloc_inode = rpc_alloc_inode,
|
|
|
|
.destroy_inode = rpc_destroy_inode,
|
|
|
|
.statfs = simple_statfs,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define RPCAUTH_GSSMAGIC 0x67596969
|
|
|
|
|
2009-08-09 13:14:21 -06:00
|
|
|
/*
|
|
|
|
* We have a single directory with 1 node in it.
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
RPCAUTH_lockd,
|
|
|
|
RPCAUTH_mount,
|
|
|
|
RPCAUTH_nfs,
|
|
|
|
RPCAUTH_portmap,
|
|
|
|
RPCAUTH_statd,
|
|
|
|
RPCAUTH_nfsd4_cb,
|
2009-08-19 16:12:27 -06:00
|
|
|
RPCAUTH_cache,
|
2012-03-21 07:52:04 -06:00
|
|
|
RPCAUTH_nfsd,
|
2013-11-14 05:25:17 -07:00
|
|
|
RPCAUTH_gssd,
|
2009-08-09 13:14:21 -06:00
|
|
|
RPCAUTH_RootEOF
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct rpc_filelist files[] = {
|
|
|
|
[RPCAUTH_lockd] = {
|
|
|
|
.name = "lockd",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2009-08-09 13:14:21 -06:00
|
|
|
},
|
|
|
|
[RPCAUTH_mount] = {
|
|
|
|
.name = "mount",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2009-08-09 13:14:21 -06:00
|
|
|
},
|
|
|
|
[RPCAUTH_nfs] = {
|
|
|
|
.name = "nfs",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2009-08-09 13:14:21 -06:00
|
|
|
},
|
|
|
|
[RPCAUTH_portmap] = {
|
|
|
|
.name = "portmap",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2009-08-09 13:14:21 -06:00
|
|
|
},
|
|
|
|
[RPCAUTH_statd] = {
|
|
|
|
.name = "statd",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2009-08-09 13:14:21 -06:00
|
|
|
},
|
|
|
|
[RPCAUTH_nfsd4_cb] = {
|
|
|
|
.name = "nfsd4_cb",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2009-08-09 13:14:21 -06:00
|
|
|
},
|
2009-08-19 16:12:27 -06:00
|
|
|
[RPCAUTH_cache] = {
|
|
|
|
.name = "cache",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2009-08-19 16:12:27 -06:00
|
|
|
},
|
2012-03-21 07:52:04 -06:00
|
|
|
[RPCAUTH_nfsd] = {
|
|
|
|
.name = "nfsd",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2012-03-21 07:52:04 -06:00
|
|
|
},
|
2013-11-14 05:25:17 -07:00
|
|
|
[RPCAUTH_gssd] = {
|
|
|
|
.name = "gssd",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2013-11-14 05:25:17 -07:00
|
|
|
},
|
2009-08-09 13:14:21 -06:00
|
|
|
};
|
|
|
|
|
2011-12-26 05:39:22 -07:00
|
|
|
/*
|
|
|
|
* This call can be used only in RPC pipefs mount notification hooks.
|
|
|
|
*/
|
|
|
|
struct dentry *rpc_d_lookup_sb(const struct super_block *sb,
|
|
|
|
const unsigned char *dir_name)
|
|
|
|
{
|
2012-05-10 14:14:12 -06:00
|
|
|
struct qstr dir = QSTR_INIT(dir_name, strlen(dir_name));
|
2013-07-14 07:09:57 -06:00
|
|
|
return d_hash_and_lookup(sb->s_root, &dir);
|
2011-12-26 05:39:22 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_d_lookup_sb);
|
|
|
|
|
2013-11-14 05:25:17 -07:00
|
|
|
int rpc_pipefs_init_net(struct net *net)
|
2011-12-26 05:39:39 -07:00
|
|
|
{
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
|
2013-11-14 05:25:17 -07:00
|
|
|
sn->gssd_dummy = rpc_mkpipe_data(&gssd_dummy_pipe_ops, 0);
|
|
|
|
if (IS_ERR(sn->gssd_dummy))
|
|
|
|
return PTR_ERR(sn->gssd_dummy);
|
|
|
|
|
2011-12-26 05:39:39 -07:00
|
|
|
mutex_init(&sn->pipefs_sb_lock);
|
2013-05-15 11:27:32 -06:00
|
|
|
sn->pipe_version = -1;
|
2013-11-14 05:25:17 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void rpc_pipefs_exit_net(struct net *net)
|
|
|
|
{
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
|
|
|
|
rpc_destroy_pipe_data(sn->gssd_dummy);
|
2011-12-26 05:39:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This call will be used for per network namespace operations calls.
|
|
|
|
* Note: Function will be returned with pipefs_sb_lock taken if superblock was
|
|
|
|
* found. This lock have to be released by rpc_put_sb_net() when all operations
|
|
|
|
* will be completed.
|
|
|
|
*/
|
|
|
|
struct super_block *rpc_get_sb_net(const struct net *net)
|
|
|
|
{
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
|
|
|
|
mutex_lock(&sn->pipefs_sb_lock);
|
|
|
|
if (sn->pipefs_sb)
|
|
|
|
return sn->pipefs_sb;
|
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_get_sb_net);
|
|
|
|
|
|
|
|
void rpc_put_sb_net(const struct net *net)
|
|
|
|
{
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
|
2012-10-23 08:43:37 -06:00
|
|
|
WARN_ON(sn->pipefs_sb == NULL);
|
2011-12-26 05:39:39 -07:00
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rpc_put_sb_net);
|
|
|
|
|
2013-11-14 05:25:17 -07:00
|
|
|
static const struct rpc_filelist gssd_dummy_clnt_dir[] = {
|
|
|
|
[0] = {
|
|
|
|
.name = "clntXX",
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFDIR | 0555,
|
2013-11-14 05:25:17 -07:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
dummy_downcall(struct file *filp, const char __user *src, size_t len)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct rpc_pipe_ops gssd_dummy_pipe_ops = {
|
|
|
|
.upcall = rpc_pipe_generic_upcall,
|
|
|
|
.downcall = dummy_downcall,
|
|
|
|
};
|
|
|
|
|
2013-12-05 05:34:44 -07:00
|
|
|
/*
|
|
|
|
* Here we present a bogus "info" file to keep rpc.gssd happy. We don't expect
|
|
|
|
* that it will ever use this info to handle an upcall, but rpc.gssd expects
|
|
|
|
* that this file will be there and have a certain format.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
rpc_show_dummy_info(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
seq_printf(m, "RPC server: %s\n", utsname()->nodename);
|
|
|
|
seq_printf(m, "service: foo (1) version 0\n");
|
|
|
|
seq_printf(m, "address: 127.0.0.1\n");
|
|
|
|
seq_printf(m, "protocol: tcp\n");
|
|
|
|
seq_printf(m, "port: 0\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_dummy_info_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, rpc_show_dummy_info, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations rpc_dummy_info_operations = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = rpc_dummy_info_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct rpc_filelist gssd_dummy_info_file[] = {
|
|
|
|
[0] = {
|
|
|
|
.name = "info",
|
|
|
|
.i_fop = &rpc_dummy_info_operations,
|
2018-03-23 16:54:38 -06:00
|
|
|
.mode = S_IFREG | 0400,
|
2013-12-05 05:34:44 -07:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2013-11-14 05:25:17 -07:00
|
|
|
/**
|
|
|
|
* rpc_gssd_dummy_populate - create a dummy gssd pipe
|
|
|
|
* @root: root of the rpc_pipefs filesystem
|
|
|
|
* @pipe_data: pipe data created when netns is initialized
|
|
|
|
*
|
|
|
|
* Create a dummy set of directories and a pipe that gssd can hold open to
|
|
|
|
* indicate that it is up and running.
|
|
|
|
*/
|
|
|
|
static struct dentry *
|
|
|
|
rpc_gssd_dummy_populate(struct dentry *root, struct rpc_pipe *pipe_data)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct dentry *gssd_dentry;
|
|
|
|
struct dentry *clnt_dentry = NULL;
|
|
|
|
struct dentry *pipe_dentry = NULL;
|
|
|
|
struct qstr q = QSTR_INIT(files[RPCAUTH_gssd].name,
|
|
|
|
strlen(files[RPCAUTH_gssd].name));
|
|
|
|
|
|
|
|
/* We should never get this far if "gssd" doesn't exist */
|
|
|
|
gssd_dentry = d_hash_and_lookup(root, &q);
|
|
|
|
if (!gssd_dentry)
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
|
|
|
ret = rpc_populate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1, NULL);
|
|
|
|
if (ret) {
|
|
|
|
pipe_dentry = ERR_PTR(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
q.name = gssd_dummy_clnt_dir[0].name;
|
|
|
|
q.len = strlen(gssd_dummy_clnt_dir[0].name);
|
|
|
|
clnt_dentry = d_hash_and_lookup(gssd_dentry, &q);
|
|
|
|
if (!clnt_dentry) {
|
|
|
|
pipe_dentry = ERR_PTR(-ENOENT);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-12-05 05:34:44 -07:00
|
|
|
ret = rpc_populate(clnt_dentry, gssd_dummy_info_file, 0, 1, NULL);
|
|
|
|
if (ret) {
|
|
|
|
__rpc_depopulate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1);
|
|
|
|
pipe_dentry = ERR_PTR(ret);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2013-11-14 05:25:17 -07:00
|
|
|
pipe_dentry = rpc_mkpipe_dentry(clnt_dentry, "gssd", NULL, pipe_data);
|
2013-12-05 05:34:44 -07:00
|
|
|
if (IS_ERR(pipe_dentry)) {
|
|
|
|
__rpc_depopulate(clnt_dentry, gssd_dummy_info_file, 0, 1);
|
2013-12-05 05:33:49 -07:00
|
|
|
__rpc_depopulate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1);
|
2013-12-05 05:34:44 -07:00
|
|
|
}
|
2013-11-14 05:25:17 -07:00
|
|
|
out:
|
|
|
|
dput(clnt_dentry);
|
|
|
|
dput(gssd_dentry);
|
|
|
|
return pipe_dentry;
|
|
|
|
}
|
|
|
|
|
2013-12-09 07:38:00 -07:00
|
|
|
static void
|
|
|
|
rpc_gssd_dummy_depopulate(struct dentry *pipe_dentry)
|
|
|
|
{
|
|
|
|
struct dentry *clnt_dir = pipe_dentry->d_parent;
|
|
|
|
struct dentry *gssd_dir = clnt_dir->d_parent;
|
|
|
|
|
2018-04-02 23:15:46 -06:00
|
|
|
dget(pipe_dentry);
|
2015-03-17 16:26:16 -06:00
|
|
|
__rpc_rmpipe(d_inode(clnt_dir), pipe_dentry);
|
2013-12-09 07:38:00 -07:00
|
|
|
__rpc_depopulate(clnt_dir, gssd_dummy_info_file, 0, 1);
|
|
|
|
__rpc_depopulate(gssd_dir, gssd_dummy_clnt_dir, 0, 1);
|
|
|
|
dput(pipe_dentry);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int
|
|
|
|
rpc_fill_super(struct super_block *sb, void *data, int silent)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
2013-11-14 05:25:17 -07:00
|
|
|
struct dentry *root, *gssd_dentry;
|
2016-05-23 13:51:59 -06:00
|
|
|
struct net *net = get_net(sb->s_fs_info);
|
2011-12-26 05:39:30 -07:00
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2011-12-26 05:39:13 -07:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
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 06:29:47 -06:00
|
|
|
sb->s_blocksize = PAGE_SIZE;
|
|
|
|
sb->s_blocksize_bits = PAGE_SHIFT;
|
2005-04-16 16:20:36 -06:00
|
|
|
sb->s_magic = RPCAUTH_GSSMAGIC;
|
|
|
|
sb->s_op = &s_ops;
|
2013-10-25 16:47:37 -06:00
|
|
|
sb->s_d_op = &simple_dentry_operations;
|
2005-04-16 16:20:36 -06:00
|
|
|
sb->s_time_gran = 1;
|
|
|
|
|
2018-03-23 16:54:38 -06:00
|
|
|
inode = rpc_get_inode(sb, S_IFDIR | 0555);
|
2012-01-08 20:15:13 -07:00
|
|
|
sb->s_root = root = d_make_root(inode);
|
|
|
|
if (!root)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
2009-08-09 13:14:20 -06:00
|
|
|
if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
|
2010-01-25 16:30:38 -07:00
|
|
|
return -ENOMEM;
|
2013-11-14 05:25:17 -07:00
|
|
|
|
|
|
|
gssd_dentry = rpc_gssd_dummy_populate(root, sn->gssd_dummy);
|
|
|
|
if (IS_ERR(gssd_dentry)) {
|
|
|
|
__rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF);
|
|
|
|
return PTR_ERR(gssd_dentry);
|
|
|
|
}
|
|
|
|
|
2017-11-07 22:57:32 -07:00
|
|
|
dprintk("RPC: sending pipefs MOUNT notification for net %x%s\n",
|
|
|
|
net->ns.inum, NET_NAME(net));
|
2013-06-24 01:52:38 -06:00
|
|
|
mutex_lock(&sn->pipefs_sb_lock);
|
2012-04-20 08:19:56 -06:00
|
|
|
sn->pipefs_sb = sb;
|
2011-12-26 05:39:13 -07:00
|
|
|
err = blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
|
|
|
|
RPC_PIPEFS_MOUNT,
|
|
|
|
sb);
|
|
|
|
if (err)
|
|
|
|
goto err_depopulate;
|
2013-06-24 01:52:38 -06:00
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2011-12-26 05:39:13 -07:00
|
|
|
|
|
|
|
err_depopulate:
|
2013-12-09 07:38:00 -07:00
|
|
|
rpc_gssd_dummy_depopulate(gssd_dentry);
|
2011-12-26 05:39:13 -07:00
|
|
|
blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
|
|
|
|
RPC_PIPEFS_UMOUNT,
|
|
|
|
sb);
|
2012-04-20 08:19:56 -06:00
|
|
|
sn->pipefs_sb = NULL;
|
2011-12-26 05:39:13 -07:00
|
|
|
__rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF);
|
2013-06-24 01:52:38 -06:00
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
2011-12-26 05:39:13 -07:00
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-11-14 05:25:18 -07:00
|
|
|
bool
|
|
|
|
gssd_running(struct net *net)
|
|
|
|
{
|
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
|
|
|
struct rpc_pipe *pipe = sn->gssd_dummy;
|
|
|
|
|
|
|
|
return pipe->nreaders || pipe->nwriters;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(gssd_running);
|
|
|
|
|
2010-07-24 15:48:30 -06:00
|
|
|
static struct dentry *
|
|
|
|
rpc_mount(struct file_system_type *fs_type,
|
|
|
|
int flags, const char *dev_name, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2016-05-23 13:51:59 -06:00
|
|
|
struct net *net = current->nsproxy->net_ns;
|
|
|
|
return mount_ns(fs_type, flags, data, net, net->user_ns, rpc_fill_super);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-03-11 13:22:54 -06:00
|
|
|
static void rpc_kill_sb(struct super_block *sb)
|
2011-12-26 05:39:04 -07:00
|
|
|
{
|
|
|
|
struct net *net = sb->s_fs_info;
|
2011-12-26 05:39:30 -07:00
|
|
|
struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
|
2011-12-26 05:39:04 -07:00
|
|
|
|
2011-12-26 05:39:39 -07:00
|
|
|
mutex_lock(&sn->pipefs_sb_lock);
|
2012-11-08 08:01:26 -07:00
|
|
|
if (sn->pipefs_sb != sb) {
|
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-26 05:39:30 -07:00
|
|
|
sn->pipefs_sb = NULL;
|
2017-11-07 22:57:32 -07:00
|
|
|
dprintk("RPC: sending pipefs UMOUNT notification for net %x%s\n",
|
|
|
|
net->ns.inum, NET_NAME(net));
|
2011-12-26 05:39:13 -07:00
|
|
|
blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
|
|
|
|
RPC_PIPEFS_UMOUNT,
|
|
|
|
sb);
|
2013-06-26 00:15:14 -06:00
|
|
|
mutex_unlock(&sn->pipefs_sb_lock);
|
2012-11-08 08:01:26 -07:00
|
|
|
out:
|
2011-12-26 05:39:04 -07:00
|
|
|
kill_litter_super(sb);
|
2016-05-23 13:51:59 -06:00
|
|
|
put_net(net);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type rpc_pipe_fs_type = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "rpc_pipefs",
|
2010-07-24 15:48:30 -06:00
|
|
|
.mount = rpc_mount,
|
2011-12-26 05:39:04 -07:00
|
|
|
.kill_sb = rpc_kill_sb,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2013-03-02 20:39:14 -07:00
|
|
|
MODULE_ALIAS_FS("rpc_pipefs");
|
2013-03-12 19:27:41 -06:00
|
|
|
MODULE_ALIAS("rpc_pipefs");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static void
|
2008-07-25 20:45:34 -06:00
|
|
|
init_once(void *foo)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct rpc_inode *rpci = (struct rpc_inode *) foo;
|
|
|
|
|
2007-05-16 23:10:57 -06:00
|
|
|
inode_init_once(&rpci->vfs_inode);
|
|
|
|
rpci->private = NULL;
|
2011-12-26 05:43:32 -07:00
|
|
|
rpci->pipe = NULL;
|
2007-05-16 23:10:57 -06:00
|
|
|
init_waitqueue_head(&rpci->waitq);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int register_rpc_pipefs(void)
|
|
|
|
{
|
2007-05-09 03:34:51 -06:00
|
|
|
int err;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
|
2006-03-24 04:16:06 -07:00
|
|
|
sizeof(struct rpc_inode),
|
|
|
|
0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
|
2016-01-14 16:18:21 -07:00
|
|
|
SLAB_MEM_SPREAD|SLAB_ACCOUNT),
|
2007-07-19 19:11:58 -06:00
|
|
|
init_once);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!rpc_inode_cachep)
|
|
|
|
return -ENOMEM;
|
2012-01-11 08:18:17 -07:00
|
|
|
err = rpc_clients_notifier_register();
|
|
|
|
if (err)
|
|
|
|
goto err_notifier;
|
2007-05-09 03:34:51 -06:00
|
|
|
err = register_filesystem(&rpc_pipe_fs_type);
|
2012-01-11 08:18:17 -07:00
|
|
|
if (err)
|
|
|
|
goto err_register;
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2012-01-11 08:18:17 -07:00
|
|
|
|
|
|
|
err_register:
|
|
|
|
rpc_clients_notifier_unregister();
|
|
|
|
err_notifier:
|
|
|
|
kmem_cache_destroy(rpc_inode_cachep);
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void unregister_rpc_pipefs(void)
|
|
|
|
{
|
2012-01-11 08:18:17 -07:00
|
|
|
rpc_clients_notifier_unregister();
|
2006-09-27 02:49:40 -06:00
|
|
|
kmem_cache_destroy(rpc_inode_cachep);
|
2005-04-16 16:20:36 -06:00
|
|
|
unregister_filesystem(&rpc_pipe_fs_type);
|
|
|
|
}
|