2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* net/sunrpc/rpc_pipe.c
|
|
|
|
*
|
|
|
|
* Userland/kernel interface for rpcauth_gss.
|
|
|
|
* Code shamelessly plagiarized from fs/nfsd/nfsctl.c
|
2005-09-01 23:59:25 -07:00
|
|
|
* and fs/sysfs/inode.c
|
2005-04-16 15:20:36 -07: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 19:44:34 -07:00
|
|
|
#include <linux/fsnotify.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
|
|
|
#include <asm/ioctls.h>
|
|
|
|
#include <linux/fs.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 12:14:30 -07:00
|
|
|
#include <linux/sunrpc/cache.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-08-26 12:05:31 -07:00
|
|
|
static struct vfsmount *rpc_mount __read_mostly;
|
2005-04-16 15:20:36 -07:00
|
|
|
static int rpc_mount_count;
|
|
|
|
|
|
|
|
static struct file_system_type rpc_pipe_fs_type;
|
|
|
|
|
|
|
|
|
2006-12-06 21:33:20 -07:00
|
|
|
static struct kmem_cache *rpc_inode_cachep __read_mostly;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
#define RPC_UPCALL_TIMEOUT (30*HZ)
|
|
|
|
|
2006-02-01 10:18:44 -07:00
|
|
|
static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
|
|
|
|
void (*destroy_msg)(struct rpc_pipe_msg *), int err)
|
2005-04-16 15:20:36 -07: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);
|
2006-02-01 10:18:44 -07:00
|
|
|
list_del(&msg->list);
|
2005-04-16 15:20:36 -07: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));
|
2005-04-16 15:20:36 -07:00
|
|
|
wake_up(&rpci->waitq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-11-22 07:55:48 -07:00
|
|
|
rpc_timeout_upcall_queue(struct work_struct *work)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-02-01 10:18:44 -07:00
|
|
|
LIST_HEAD(free_list);
|
2006-11-22 07:55:48 -07:00
|
|
|
struct rpc_inode *rpci =
|
|
|
|
container_of(work, struct rpc_inode, queue_timeout.work);
|
2005-04-16 15:20:36 -07:00
|
|
|
struct inode *inode = &rpci->vfs_inode;
|
2006-02-01 10:18:44 -07:00
|
|
|
void (*destroy_msg)(struct rpc_pipe_msg *);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-02-01 10:18:44 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
if (rpci->ops == NULL) {
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
destroy_msg = rpci->ops->destroy_msg;
|
|
|
|
if (rpci->nreaders == 0) {
|
|
|
|
list_splice_init(&rpci->pipe, &free_list);
|
|
|
|
rpci->pipelen = 0;
|
|
|
|
}
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2007-11-06 11:06:03 -07:00
|
|
|
/**
|
|
|
|
* rpc_queue_upcall
|
|
|
|
* @inode: inode of upcall pipe on which to queue given message
|
|
|
|
* @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 15:20:36 -07:00
|
|
|
int
|
|
|
|
rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
|
|
|
|
{
|
|
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
2005-10-27 19:12:46 -07:00
|
|
|
int res = -EPIPE;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-02-01 10:18:44 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-10-27 19:12:46 -07:00
|
|
|
if (rpci->ops == NULL)
|
|
|
|
goto out;
|
2005-04-16 15:20:36 -07:00
|
|
|
if (rpci->nreaders) {
|
|
|
|
list_add_tail(&msg->list, &rpci->pipe);
|
|
|
|
rpci->pipelen += msg->len;
|
2005-10-27 19:12:46 -07:00
|
|
|
res = 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
} else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
|
|
|
|
if (list_empty(&rpci->pipe))
|
2006-03-20 11:44:08 -07:00
|
|
|
queue_delayed_work(rpciod_workqueue,
|
|
|
|
&rpci->queue_timeout,
|
2005-04-16 15:20:36 -07:00
|
|
|
RPC_UPCALL_TIMEOUT);
|
|
|
|
list_add_tail(&msg->list, &rpci->pipe);
|
|
|
|
rpci->pipelen += msg->len;
|
2005-10-27 19:12:46 -07:00
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
out:
|
2006-02-01 10:18:44 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 15:20:36 -07:00
|
|
|
wake_up(&rpci->waitq);
|
|
|
|
return res;
|
|
|
|
}
|
2008-12-23 13:21:31 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_queue_upcall);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-10-27 19:12:46 -07:00
|
|
|
static inline void
|
|
|
|
rpc_inode_setowner(struct inode *inode, void *private)
|
|
|
|
{
|
|
|
|
RPC_I(inode)->private = private;
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
static void
|
|
|
|
rpc_close_pipes(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
2009-08-09 12:14:15 -07:00
|
|
|
const struct rpc_pipe_ops *ops;
|
2008-12-23 14:09:47 -07:00
|
|
|
int need_release;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2006-02-01 10:18:44 -07:00
|
|
|
ops = rpci->ops;
|
|
|
|
if (ops != NULL) {
|
|
|
|
LIST_HEAD(free_list);
|
|
|
|
spin_lock(&inode->i_lock);
|
2008-12-23 14:09:47 -07:00
|
|
|
need_release = rpci->nreaders != 0 || rpci->nwriters != 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
rpci->nreaders = 0;
|
2006-02-01 10:18:44 -07:00
|
|
|
list_splice_init(&rpci->in_upcall, &free_list);
|
|
|
|
list_splice_init(&rpci->pipe, &free_list);
|
|
|
|
rpci->pipelen = 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
rpci->ops = NULL;
|
2006-02-01 10:18:44 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
|
|
|
|
rpci->nwriters = 0;
|
2008-12-23 14:09:47 -07:00
|
|
|
if (need_release && ops->release_pipe)
|
2006-02-01 10:18:44 -07:00
|
|
|
ops->release_pipe(inode);
|
2007-08-07 12:33:01 -07:00
|
|
|
cancel_delayed_work_sync(&rpci->queue_timeout);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2005-10-27 19:12:46 -07:00
|
|
|
rpc_inode_setowner(inode, NULL);
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct inode *
|
|
|
|
rpc_alloc_inode(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct rpc_inode *rpci;
|
2006-12-06 21:33:17 -07:00
|
|
|
rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (!rpci)
|
|
|
|
return NULL;
|
|
|
|
return &rpci->vfs_inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
rpc_destroy_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_pipe_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
2008-12-23 14:08:32 -07:00
|
|
|
int first_open;
|
2005-04-16 15:20:36 -07:00
|
|
|
int res = -ENXIO;
|
|
|
|
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2008-12-23 14:08:32 -07:00
|
|
|
if (rpci->ops == NULL)
|
|
|
|
goto out;
|
|
|
|
first_open = rpci->nreaders == 0 && rpci->nwriters == 0;
|
|
|
|
if (first_open && rpci->ops->open_pipe) {
|
|
|
|
res = rpci->ops->open_pipe(inode);
|
|
|
|
if (res)
|
|
|
|
goto out;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2008-12-23 14:08:32 -07:00
|
|
|
if (filp->f_mode & FMODE_READ)
|
|
|
|
rpci->nreaders++;
|
|
|
|
if (filp->f_mode & FMODE_WRITE)
|
|
|
|
rpci->nwriters++;
|
|
|
|
res = 0;
|
|
|
|
out:
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_pipe_release(struct inode *inode, struct file *filp)
|
|
|
|
{
|
2006-01-03 01:55:36 -07:00
|
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
struct rpc_pipe_msg *msg;
|
2008-12-23 14:09:47 -07:00
|
|
|
int last_close;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (rpci->ops == NULL)
|
|
|
|
goto out;
|
|
|
|
msg = (struct rpc_pipe_msg *)filp->private_data;
|
|
|
|
if (msg != NULL) {
|
2006-02-01 10:18:44 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-12-19 15:11:22 -07:00
|
|
|
msg->errno = -EAGAIN;
|
2006-02-01 10:18:44 -07:00
|
|
|
list_del(&msg->list);
|
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 15:20:36 -07:00
|
|
|
rpci->ops->destroy_msg(msg);
|
|
|
|
}
|
|
|
|
if (filp->f_mode & FMODE_WRITE)
|
|
|
|
rpci->nwriters --;
|
2006-02-01 10:18:44 -07:00
|
|
|
if (filp->f_mode & FMODE_READ) {
|
2005-04-16 15:20:36 -07:00
|
|
|
rpci->nreaders --;
|
2006-02-01 10:18:44 -07:00
|
|
|
if (rpci->nreaders == 0) {
|
|
|
|
LIST_HEAD(free_list);
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
list_splice_init(&rpci->pipe, &free_list);
|
|
|
|
rpci->pipelen = 0;
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
rpc_purge_list(rpci, &free_list,
|
|
|
|
rpci->ops->destroy_msg, -EAGAIN);
|
|
|
|
}
|
|
|
|
}
|
2008-12-23 14:09:47 -07:00
|
|
|
last_close = rpci->nwriters == 0 && rpci->nreaders == 0;
|
|
|
|
if (last_close && rpci->ops->release_pipe)
|
2005-04-16 15:20:36 -07:00
|
|
|
rpci->ops->release_pipe(inode);
|
|
|
|
out:
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
|
|
|
|
{
|
2006-12-08 03:37:42 -07:00
|
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
|
|
|
struct rpc_pipe_msg *msg;
|
|
|
|
int res = 0;
|
|
|
|
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (rpci->ops == NULL) {
|
|
|
|
res = -EPIPE;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
msg = filp->private_data;
|
|
|
|
if (msg == NULL) {
|
2006-02-01 10:18:44 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (!list_empty(&rpci->pipe)) {
|
|
|
|
msg = list_entry(rpci->pipe.next,
|
|
|
|
struct rpc_pipe_msg,
|
|
|
|
list);
|
|
|
|
list_move(&msg->list, &rpci->in_upcall);
|
|
|
|
rpci->pipelen -= msg->len;
|
|
|
|
filp->private_data = msg;
|
|
|
|
msg->copied = 0;
|
|
|
|
}
|
2006-02-01 10:18:44 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (msg == NULL)
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
/* NOTE: it is up to the callback to update msg->copied */
|
|
|
|
res = rpci->ops->upcall(filp, msg, buf, len);
|
|
|
|
if (res < 0 || msg->len == msg->copied) {
|
|
|
|
filp->private_data = NULL;
|
2006-02-01 10:18:44 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
list_del(&msg->list);
|
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 15:20:36 -07:00
|
|
|
rpci->ops->destroy_msg(msg);
|
|
|
|
}
|
|
|
|
out_unlock:
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
|
|
|
|
{
|
2006-12-08 03:37:42 -07:00
|
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
|
|
|
int res;
|
|
|
|
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
res = -EPIPE;
|
|
|
|
if (rpci->ops != NULL)
|
|
|
|
res = rpci->ops->downcall(filp, buf, len);
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
|
|
|
|
{
|
|
|
|
struct rpc_inode *rpci;
|
|
|
|
unsigned int mask = 0;
|
|
|
|
|
2006-12-08 03:37:42 -07:00
|
|
|
rpci = RPC_I(filp->f_path.dentry->d_inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
poll_wait(filp, &rpci->waitq, wait);
|
|
|
|
|
|
|
|
mask = POLLOUT | POLLWRNORM;
|
|
|
|
if (rpci->ops == NULL)
|
|
|
|
mask |= POLLERR | POLLHUP;
|
2007-11-06 11:05:36 -07:00
|
|
|
if (filp->private_data || !list_empty(&rpci->pipe))
|
2005-04-16 15:20:36 -07:00
|
|
|
mask |= POLLIN | POLLRDNORM;
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_pipe_ioctl(struct inode *ino, struct file *filp,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
2006-12-08 03:37:42 -07:00
|
|
|
struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
int len;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case FIONREAD:
|
|
|
|
if (rpci->ops == NULL)
|
|
|
|
return -EPIPE;
|
|
|
|
len = rpci->pipelen;
|
|
|
|
if (filp->private_data) {
|
|
|
|
struct rpc_pipe_msg *msg;
|
|
|
|
msg = (struct rpc_pipe_msg *)filp->private_data;
|
|
|
|
len += msg->len - msg->copied;
|
|
|
|
}
|
|
|
|
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 15:20:36 -07:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.llseek = no_llseek,
|
|
|
|
.read = rpc_pipe_read,
|
|
|
|
.write = rpc_pipe_write,
|
|
|
|
.poll = rpc_pipe_poll,
|
|
|
|
.ioctl = rpc_pipe_ioctl,
|
|
|
|
.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;
|
|
|
|
|
|
|
|
seq_printf(m, "RPC server: %s\n", clnt->cl_server);
|
|
|
|
seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
|
|
|
|
clnt->cl_prog, clnt->cl_vers);
|
2006-08-22 17:06:19 -07: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 11:38:09 -07:00
|
|
|
seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
|
2005-04-16 15:20:36 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
rpc_info_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct rpc_clnt *clnt;
|
|
|
|
int ret = single_open(file, rpc_show_info, NULL);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
struct seq_file *m = file->private_data;
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_lock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
clnt = RPC_I(inode)->private;
|
|
|
|
if (clnt) {
|
2007-06-14 13:40:31 -07:00
|
|
|
kref_get(&clnt->cl_kref);
|
2005-04-16 15:20:36 -07:00
|
|
|
m->private = clnt;
|
|
|
|
} else {
|
|
|
|
single_release(inode, file);
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
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 15:20:36 -07: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 12:14:20 -07:00
|
|
|
const char *name;
|
2006-03-28 02:56:41 -07:00
|
|
|
const struct file_operations *i_fop;
|
2009-08-09 12:14:16 -07:00
|
|
|
umode_t mode;
|
2005-04-16 15:20:36 -07:00
|
|
|
};
|
|
|
|
|
2006-03-20 11:44:49 -07:00
|
|
|
struct vfsmount *rpc_get_mount(void)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-03-20 11:44:49 -07:00
|
|
|
int err;
|
|
|
|
|
2006-06-09 06:34:16 -07:00
|
|
|
err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mount, &rpc_mount_count);
|
2006-03-20 11:44:49 -07:00
|
|
|
if (err != 0)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
return rpc_mount;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2009-08-19 15:12:27 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_get_mount);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-03-20 11:44:49 -07:00
|
|
|
void rpc_put_mount(void)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
simple_release_fs(&rpc_mount, &rpc_mount_count);
|
|
|
|
}
|
2009-08-19 15:12:27 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_put_mount);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-06-08 11:14:46 -07:00
|
|
|
static int rpc_delete_dentry(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-02-19 23:02:22 -07:00
|
|
|
static const struct dentry_operations rpc_dentry_operations = {
|
2007-06-08 11:14:46 -07:00
|
|
|
.d_delete = rpc_delete_dentry,
|
|
|
|
};
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
static struct inode *
|
2009-08-09 12:14:16 -07:00
|
|
|
rpc_get_inode(struct super_block *sb, umode_t mode)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct inode *inode = new_inode(sb);
|
|
|
|
if (!inode)
|
|
|
|
return NULL;
|
|
|
|
inode->i_mode = mode;
|
|
|
|
inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
|
|
|
|
switch(mode & S_IFMT) {
|
|
|
|
case S_IFDIR:
|
|
|
|
inode->i_fop = &simple_dir_operations;
|
|
|
|
inode->i_op = &simple_dir_inode_operations;
|
2006-09-30 23:29:04 -07:00
|
|
|
inc_nlink(inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
2009-08-09 12:14:17 -07: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;
|
|
|
|
|
|
|
|
BUG_ON(!d_unhashed(dentry));
|
|
|
|
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:
|
|
|
|
printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
|
|
|
|
__FILE__, __func__, dentry->d_name.name);
|
|
|
|
dput(dentry);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-08-09 12:14:20 -07: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 12:14:17 -07: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __rpc_mkpipe(struct inode *dir, struct dentry *dentry,
|
|
|
|
umode_t mode,
|
|
|
|
const struct file_operations *i_fop,
|
|
|
|
void *private,
|
|
|
|
const struct rpc_pipe_ops *ops,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
struct rpc_inode *rpci;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
rpci = RPC_I(dentry->d_inode);
|
|
|
|
rpci->nkern_readwriters = 1;
|
|
|
|
rpci->private = private;
|
|
|
|
rpci->flags = flags;
|
|
|
|
rpci->ops = ops;
|
|
|
|
fsnotify_create(dir, dentry);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-09 12:14:20 -07: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 12:14:18 -07: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)
|
|
|
|
{
|
|
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
|
|
|
|
|
|
|
rpci->nkern_readwriters--;
|
|
|
|
if (rpci->nkern_readwriters != 0)
|
|
|
|
return 0;
|
|
|
|
rpc_close_pipes(inode);
|
|
|
|
return __rpc_unlink(dir, dentry);
|
|
|
|
}
|
|
|
|
|
2009-08-09 12:14:20 -07:00
|
|
|
static struct dentry *__rpc_lookup_create(struct dentry *parent,
|
|
|
|
struct qstr *name)
|
|
|
|
{
|
|
|
|
struct dentry *dentry;
|
|
|
|
|
|
|
|
dentry = d_lookup(parent, name);
|
|
|
|
if (!dentry) {
|
|
|
|
dentry = d_alloc(parent, name);
|
|
|
|
if (!dentry) {
|
|
|
|
dentry = ERR_PTR(-ENOMEM);
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!dentry->d_inode)
|
|
|
|
dentry->d_op = &rpc_dentry_operations;
|
|
|
|
out_err:
|
|
|
|
return dentry;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
|
|
|
|
struct qstr *name)
|
|
|
|
{
|
|
|
|
struct dentry *dentry;
|
|
|
|
|
|
|
|
dentry = __rpc_lookup_create(parent, name);
|
|
|
|
if (dentry->d_inode == NULL)
|
|
|
|
return dentry;
|
|
|
|
dput(dentry);
|
|
|
|
return ERR_PTR(-EEXIST);
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* FIXME: This probably has races.
|
|
|
|
*/
|
2009-08-09 12:14:20 -07:00
|
|
|
static void __rpc_depopulate(struct dentry *parent,
|
|
|
|
const struct rpc_filelist *files,
|
|
|
|
int start, int eof)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct inode *dir = parent->d_inode;
|
2009-08-09 12:14:20 -07:00
|
|
|
struct dentry *dentry;
|
|
|
|
struct qstr name;
|
|
|
|
int i;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2009-08-09 12:14:20 -07:00
|
|
|
for (i = start; i < eof; i++) {
|
|
|
|
name.name = files[i].name;
|
|
|
|
name.len = strlen(files[i].name);
|
|
|
|
name.hash = full_name_hash(name.name, name.len);
|
|
|
|
dentry = d_lookup(parent, &name);
|
|
|
|
|
|
|
|
if (dentry == NULL)
|
2007-06-08 11:14:46 -07:00
|
|
|
continue;
|
2009-08-09 12:14:20 -07:00
|
|
|
if (dentry->d_inode == NULL)
|
|
|
|
goto next;
|
|
|
|
switch (dentry->d_inode->i_mode & S_IFMT) {
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
case S_IFREG:
|
|
|
|
__rpc_unlink(dir, dentry);
|
2005-04-16 15:20:36 -07:00
|
|
|
break;
|
2009-08-09 12:14:20 -07:00
|
|
|
case S_IFDIR:
|
|
|
|
__rpc_rmdir(dir, dentry);
|
|
|
|
}
|
|
|
|
next:
|
|
|
|
dput(dentry);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2009-08-09 12:14:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rpc_depopulate(struct dentry *parent,
|
|
|
|
const struct rpc_filelist *files,
|
|
|
|
int start, int eof)
|
|
|
|
{
|
|
|
|
struct inode *dir = parent->d_inode;
|
|
|
|
|
|
|
|
mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
|
|
|
|
__rpc_depopulate(parent, files, start, eof);
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&dir->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2009-08-09 12:14:20 -07:00
|
|
|
static int rpc_populate(struct dentry *parent,
|
|
|
|
const struct rpc_filelist *files,
|
|
|
|
int start, int eof,
|
|
|
|
void *private)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2009-08-09 12:14:20 -07:00
|
|
|
struct inode *dir = parent->d_inode;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct dentry *dentry;
|
2009-08-09 12:14:20 -07:00
|
|
|
int i, err;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_lock(&dir->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
for (i = start; i < eof; i++) {
|
2009-08-09 12:14:20 -07:00
|
|
|
struct qstr q;
|
|
|
|
|
|
|
|
q.name = files[i].name;
|
|
|
|
q.len = strlen(files[i].name);
|
|
|
|
q.hash = full_name_hash(q.name, q.len);
|
|
|
|
dentry = __rpc_lookup_create_exclusive(parent, &q);
|
|
|
|
err = PTR_ERR(dentry);
|
|
|
|
if (IS_ERR(dentry))
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out_bad;
|
2009-08-09 12:14:20 -07: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 15:20:36 -07:00
|
|
|
}
|
2009-08-09 12:14:20 -07:00
|
|
|
if (err != 0)
|
|
|
|
goto out_bad;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&dir->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
return 0;
|
|
|
|
out_bad:
|
2009-08-09 12:14:20 -07:00
|
|
|
__rpc_depopulate(parent, files, start, eof);
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&dir->i_mutex);
|
2005-04-16 15:20:36 -07:00
|
|
|
printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
__FILE__, __func__, parent->d_name.name);
|
2009-08-09 12:14:20 -07:00
|
|
|
return err;
|
2005-09-23 08:08:25 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2009-08-09 12:14:26 -07:00
|
|
|
static struct dentry *rpc_mkdir_populate(struct dentry *parent,
|
|
|
|
struct qstr *name, umode_t mode, void *private,
|
|
|
|
int (*populate)(struct dentry *, void *), void *args_populate)
|
2005-09-23 08:08:25 -07:00
|
|
|
{
|
|
|
|
struct dentry *dentry;
|
2009-08-09 12:14:23 -07:00
|
|
|
struct inode *dir = parent->d_inode;
|
2005-09-23 08:08:25 -07:00
|
|
|
int error;
|
|
|
|
|
2009-08-09 12:14:23 -07:00
|
|
|
mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
|
|
|
|
dentry = __rpc_lookup_create_exclusive(parent, name);
|
2005-09-23 08:08:25 -07:00
|
|
|
if (IS_ERR(dentry))
|
2009-08-09 12:14:23 -07:00
|
|
|
goto out;
|
|
|
|
error = __rpc_mkdir(dir, dentry, mode, NULL, private);
|
2009-08-09 12:14:17 -07:00
|
|
|
if (error != 0)
|
|
|
|
goto out_err;
|
2009-08-09 12:14:26 -07:00
|
|
|
if (populate != NULL) {
|
|
|
|
error = populate(dentry, args_populate);
|
|
|
|
if (error)
|
|
|
|
goto err_rmdir;
|
|
|
|
}
|
2005-09-23 08:08:25 -07:00
|
|
|
out:
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&dir->i_mutex);
|
2006-07-29 14:37:40 -07:00
|
|
|
return dentry;
|
2009-08-09 12:14:20 -07:00
|
|
|
err_rmdir:
|
2005-09-23 08:08:25 -07:00
|
|
|
__rpc_rmdir(dir, dentry);
|
2009-08-09 12:14:17 -07:00
|
|
|
out_err:
|
2005-09-23 08:08:25 -07:00
|
|
|
dentry = ERR_PTR(error);
|
|
|
|
goto out;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2009-08-09 12:14:26 -07:00
|
|
|
static int rpc_rmdir_depopulate(struct dentry *dentry,
|
|
|
|
void (*depopulate)(struct dentry *))
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-07-31 14:17:18 -07:00
|
|
|
struct dentry *parent;
|
2005-09-23 08:08:25 -07:00
|
|
|
struct inode *dir;
|
|
|
|
int error;
|
2005-07-24 15:53:01 -07:00
|
|
|
|
2006-07-31 14:17:18 -07:00
|
|
|
parent = dget_parent(dentry);
|
|
|
|
dir = parent->d_inode;
|
2006-07-03 00:25:16 -07:00
|
|
|
mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
|
2009-08-09 12:14:26 -07:00
|
|
|
if (depopulate != NULL)
|
|
|
|
depopulate(dentry);
|
2005-09-23 08:08:25 -07:00
|
|
|
error = __rpc_rmdir(dir, dentry);
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&dir->i_mutex);
|
2006-07-31 14:17:18 -07:00
|
|
|
dput(parent);
|
2005-09-23 08:08:25 -07:00
|
|
|
return error;
|
2005-04-16 15:20:36 -07: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
|
|
|
|
* @ops: operations defining the behavior of the pipe: upcall, downcall,
|
2008-12-23 14:08:32 -07:00
|
|
|
* release_pipe, open_pipe, and destroy_msg.
|
2008-02-13 16:03:23 -07:00
|
|
|
* @flags: rpc_inode flags
|
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
|
|
|
|
* from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
|
|
|
|
*/
|
2009-08-09 12:14:15 -07:00
|
|
|
struct dentry *rpc_mkpipe(struct dentry *parent, const char *name,
|
|
|
|
void *private, const struct rpc_pipe_ops *ops,
|
|
|
|
int flags)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct dentry *dentry;
|
2009-08-09 12:14:17 -07:00
|
|
|
struct inode *dir = parent->d_inode;
|
2009-08-09 12:14:16 -07:00
|
|
|
umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR;
|
2009-08-09 12:14:20 -07:00
|
|
|
struct qstr q;
|
2009-08-09 12:14:17 -07:00
|
|
|
int err;
|
2009-08-09 12:14:16 -07:00
|
|
|
|
|
|
|
if (ops->upcall == NULL)
|
|
|
|
umode &= ~S_IRUGO;
|
|
|
|
if (ops->downcall == NULL)
|
|
|
|
umode &= ~S_IWUGO;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2009-08-09 12:14:20 -07:00
|
|
|
q.name = name;
|
|
|
|
q.len = strlen(name);
|
|
|
|
q.hash = full_name_hash(q.name, q.len),
|
|
|
|
|
|
|
|
mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
|
|
|
|
dentry = __rpc_lookup_create(parent, &q);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (IS_ERR(dentry))
|
2009-08-09 12:14:20 -07:00
|
|
|
goto out;
|
2007-06-07 15:28:02 -07:00
|
|
|
if (dentry->d_inode) {
|
2009-08-09 12:14:17 -07:00
|
|
|
struct rpc_inode *rpci = RPC_I(dentry->d_inode);
|
2007-06-07 15:28:02 -07:00
|
|
|
if (rpci->private != private ||
|
|
|
|
rpci->ops != ops ||
|
|
|
|
rpci->flags != flags) {
|
|
|
|
dput (dentry);
|
2009-08-09 12:14:18 -07:00
|
|
|
err = -EBUSY;
|
|
|
|
goto out_err;
|
2007-06-07 15:28:02 -07:00
|
|
|
}
|
2007-06-08 11:14:53 -07:00
|
|
|
rpci->nkern_readwriters++;
|
2007-06-07 15:28:02 -07:00
|
|
|
goto out;
|
|
|
|
}
|
2009-08-09 12:14:17 -07:00
|
|
|
|
|
|
|
err = __rpc_mkpipe(dir, dentry, umode, &rpc_pipe_fops,
|
2009-08-09 12:14:18 -07:00
|
|
|
private, ops, flags);
|
2009-08-09 12:14:17 -07:00
|
|
|
if (err)
|
|
|
|
goto out_err;
|
2005-09-23 08:08:25 -07:00
|
|
|
out:
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&dir->i_mutex);
|
2006-07-29 14:37:40 -07:00
|
|
|
return dentry;
|
2009-08-09 12:14:17 -07:00
|
|
|
out_err:
|
|
|
|
dentry = ERR_PTR(err);
|
2006-08-23 22:03:17 -07:00
|
|
|
printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
|
2008-03-05 21:47:47 -07:00
|
|
|
__FILE__, __func__, parent->d_name.name, name,
|
2009-08-09 12:14:17 -07:00
|
|
|
err);
|
2005-09-23 08:08:25 -07:00
|
|
|
goto out;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2008-12-23 13:21:31 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_mkpipe);
|
2005-04-16 15:20:36 -07: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 08:08:25 -07:00
|
|
|
int
|
2006-07-31 14:11:48 -07:00
|
|
|
rpc_unlink(struct dentry *dentry)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-07-31 14:11:48 -07:00
|
|
|
struct dentry *parent;
|
2005-09-23 08:08:25 -07:00
|
|
|
struct inode *dir;
|
2006-07-31 14:11:48 -07:00
|
|
|
int error = 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-07-31 14:11:48 -07:00
|
|
|
parent = dget_parent(dentry);
|
|
|
|
dir = parent->d_inode;
|
2006-07-03 00:25:16 -07:00
|
|
|
mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
|
2009-08-09 12:14:18 -07:00
|
|
|
error = __rpc_rmpipe(dir, dentry);
|
2006-01-09 16:59:24 -07:00
|
|
|
mutex_unlock(&dir->i_mutex);
|
2006-07-31 14:11:48 -07:00
|
|
|
dput(parent);
|
2005-09-23 08:08:25 -07:00
|
|
|
return error;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2008-12-23 13:21:31 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rpc_unlink);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2009-08-09 12:14:26 -07:00
|
|
|
enum {
|
|
|
|
RPCAUTH_info,
|
|
|
|
RPCAUTH_EOF
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct rpc_filelist authfiles[] = {
|
|
|
|
[RPCAUTH_info] = {
|
|
|
|
.name = "info",
|
|
|
|
.i_fop = &rpc_info_operations,
|
|
|
|
.mode = S_IFREG | S_IRUSR,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
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 12:14:23 -07:00
|
|
|
/**
|
|
|
|
* rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
|
2009-09-23 11:36:38 -07:00
|
|
|
* @dentry: dentry from the rpc_pipefs root to the new directory
|
|
|
|
* @name: &struct qstr for the name
|
2009-08-09 12:14:23 -07: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 12:14:25 -07:00
|
|
|
struct dentry *rpc_create_client_dir(struct dentry *dentry,
|
2009-08-09 12:14:26 -07:00
|
|
|
struct qstr *name,
|
|
|
|
struct rpc_clnt *rpc_client)
|
|
|
|
{
|
|
|
|
return rpc_mkdir_populate(dentry, name, S_IRUGO | S_IXUGO, NULL,
|
|
|
|
rpc_clntdir_populate, rpc_client);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
|
|
|
|
* @dentry: directory to remove
|
|
|
|
*/
|
|
|
|
int rpc_remove_client_dir(struct dentry *dentry)
|
2009-08-09 12:14:23 -07:00
|
|
|
{
|
2009-08-09 12:14:26 -07:00
|
|
|
return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
|
2009-08-09 12:14:23 -07:00
|
|
|
}
|
|
|
|
|
2009-08-09 12:14:30 -07:00
|
|
|
static const struct rpc_filelist cache_pipefs_files[3] = {
|
|
|
|
[0] = {
|
|
|
|
.name = "channel",
|
|
|
|
.i_fop = &cache_file_operations_pipefs,
|
2009-08-19 15:12:21 -07:00
|
|
|
.mode = S_IFREG|S_IRUSR|S_IWUSR,
|
2009-08-09 12:14:30 -07:00
|
|
|
},
|
|
|
|
[1] = {
|
|
|
|
.name = "content",
|
|
|
|
.i_fop = &content_file_operations_pipefs,
|
|
|
|
.mode = S_IFREG|S_IRUSR,
|
|
|
|
},
|
|
|
|
[2] = {
|
|
|
|
.name = "flush",
|
|
|
|
.i_fop = &cache_flush_operations_pipefs,
|
|
|
|
.mode = S_IFREG|S_IRUSR|S_IWUSR,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct dentry *rpc_create_cache_dir(struct dentry *parent, struct qstr *name,
|
|
|
|
mode_t umode, struct cache_detail *cd)
|
|
|
|
{
|
|
|
|
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 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* populate the filesystem
|
|
|
|
*/
|
2009-09-21 17:01:09 -07:00
|
|
|
static const struct super_operations s_ops = {
|
2005-04-16 15:20:36 -07:00
|
|
|
.alloc_inode = rpc_alloc_inode,
|
|
|
|
.destroy_inode = rpc_destroy_inode,
|
|
|
|
.statfs = simple_statfs,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define RPCAUTH_GSSMAGIC 0x67596969
|
|
|
|
|
2009-08-09 12:14:21 -07: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 15:12:27 -07:00
|
|
|
RPCAUTH_cache,
|
2009-08-09 12:14:21 -07:00
|
|
|
RPCAUTH_RootEOF
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct rpc_filelist files[] = {
|
|
|
|
[RPCAUTH_lockd] = {
|
|
|
|
.name = "lockd",
|
|
|
|
.mode = S_IFDIR | S_IRUGO | S_IXUGO,
|
|
|
|
},
|
|
|
|
[RPCAUTH_mount] = {
|
|
|
|
.name = "mount",
|
|
|
|
.mode = S_IFDIR | S_IRUGO | S_IXUGO,
|
|
|
|
},
|
|
|
|
[RPCAUTH_nfs] = {
|
|
|
|
.name = "nfs",
|
|
|
|
.mode = S_IFDIR | S_IRUGO | S_IXUGO,
|
|
|
|
},
|
|
|
|
[RPCAUTH_portmap] = {
|
|
|
|
.name = "portmap",
|
|
|
|
.mode = S_IFDIR | S_IRUGO | S_IXUGO,
|
|
|
|
},
|
|
|
|
[RPCAUTH_statd] = {
|
|
|
|
.name = "statd",
|
|
|
|
.mode = S_IFDIR | S_IRUGO | S_IXUGO,
|
|
|
|
},
|
|
|
|
[RPCAUTH_nfsd4_cb] = {
|
|
|
|
.name = "nfsd4_cb",
|
|
|
|
.mode = S_IFDIR | S_IRUGO | S_IXUGO,
|
|
|
|
},
|
2009-08-19 15:12:27 -07:00
|
|
|
[RPCAUTH_cache] = {
|
|
|
|
.name = "cache",
|
|
|
|
.mode = S_IFDIR | S_IRUGO | S_IXUGO,
|
|
|
|
},
|
2009-08-09 12:14:21 -07:00
|
|
|
};
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
static int
|
|
|
|
rpc_fill_super(struct super_block *sb, void *data, int silent)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
struct dentry *root;
|
|
|
|
|
|
|
|
sb->s_blocksize = PAGE_CACHE_SIZE;
|
|
|
|
sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
|
|
|
|
sb->s_magic = RPCAUTH_GSSMAGIC;
|
|
|
|
sb->s_op = &s_ops;
|
|
|
|
sb->s_time_gran = 1;
|
|
|
|
|
|
|
|
inode = rpc_get_inode(sb, S_IFDIR | 0755);
|
|
|
|
if (!inode)
|
|
|
|
return -ENOMEM;
|
|
|
|
root = d_alloc_root(inode);
|
|
|
|
if (!root) {
|
|
|
|
iput(inode);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2009-08-09 12:14:20 -07:00
|
|
|
if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out;
|
|
|
|
sb->s_root = root;
|
|
|
|
return 0;
|
|
|
|
out:
|
|
|
|
d_genocide(root);
|
|
|
|
dput(root);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 02:02:57 -07:00
|
|
|
static int
|
2005-04-16 15:20:36 -07:00
|
|
|
rpc_get_sb(struct file_system_type *fs_type,
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 02:02:57 -07:00
|
|
|
int flags, const char *dev_name, void *data, struct vfsmount *mnt)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 02:02:57 -07:00
|
|
|
return get_sb_single(fs_type, flags, data, rpc_fill_super, mnt);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type rpc_pipe_fs_type = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "rpc_pipefs",
|
|
|
|
.get_sb = rpc_get_sb,
|
|
|
|
.kill_sb = kill_litter_super,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
2008-07-25 19:45:34 -07:00
|
|
|
init_once(void *foo)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct rpc_inode *rpci = (struct rpc_inode *) foo;
|
|
|
|
|
2007-05-16 22:10:57 -07:00
|
|
|
inode_init_once(&rpci->vfs_inode);
|
|
|
|
rpci->private = NULL;
|
|
|
|
rpci->nreaders = 0;
|
|
|
|
rpci->nwriters = 0;
|
|
|
|
INIT_LIST_HEAD(&rpci->in_upcall);
|
2007-06-07 12:31:36 -07:00
|
|
|
INIT_LIST_HEAD(&rpci->in_downcall);
|
2007-05-16 22:10:57 -07:00
|
|
|
INIT_LIST_HEAD(&rpci->pipe);
|
|
|
|
rpci->pipelen = 0;
|
|
|
|
init_waitqueue_head(&rpci->waitq);
|
|
|
|
INIT_DELAYED_WORK(&rpci->queue_timeout,
|
|
|
|
rpc_timeout_upcall_queue);
|
|
|
|
rpci->ops = NULL;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int register_rpc_pipefs(void)
|
|
|
|
{
|
2007-05-09 02:34:51 -07:00
|
|
|
int err;
|
|
|
|
|
2005-04-16 15:20:36 -07: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|
|
|
|
|
SLAB_MEM_SPREAD),
|
2007-07-19 18:11:58 -07:00
|
|
|
init_once);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (!rpc_inode_cachep)
|
|
|
|
return -ENOMEM;
|
2007-05-09 02:34:51 -07:00
|
|
|
err = register_filesystem(&rpc_pipe_fs_type);
|
|
|
|
if (err) {
|
|
|
|
kmem_cache_destroy(rpc_inode_cachep);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void unregister_rpc_pipefs(void)
|
|
|
|
{
|
2006-09-27 01:49:40 -07:00
|
|
|
kmem_cache_destroy(rpc_inode_cachep);
|
2005-04-16 15:20:36 -07:00
|
|
|
unregister_filesystem(&rpc_pipe_fs_type);
|
|
|
|
}
|