forked from luck/tmp_suning_uos_patched
454e2398be
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>
871 lines
19 KiB
C
871 lines
19 KiB
C
/*
|
|
* net/sunrpc/rpc_pipe.c
|
|
*
|
|
* Userland/kernel interface for rpcauth_gss.
|
|
* Code shamelessly plagiarized from fs/nfsd/nfsctl.c
|
|
* and fs/sysfs/inode.c
|
|
*
|
|
* Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
|
|
*
|
|
*/
|
|
#include <linux/config.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/string.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/namei.h>
|
|
#include <linux/dnotify.h>
|
|
#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>
|
|
|
|
static struct vfsmount *rpc_mount __read_mostly;
|
|
static int rpc_mount_count;
|
|
|
|
static struct file_system_type rpc_pipe_fs_type;
|
|
|
|
|
|
static kmem_cache_t *rpc_inode_cachep __read_mostly;
|
|
|
|
#define RPC_UPCALL_TIMEOUT (30*HZ)
|
|
|
|
static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
|
|
void (*destroy_msg)(struct rpc_pipe_msg *), int err)
|
|
{
|
|
struct rpc_pipe_msg *msg;
|
|
|
|
if (list_empty(head))
|
|
return;
|
|
do {
|
|
msg = list_entry(head->next, struct rpc_pipe_msg, list);
|
|
list_del(&msg->list);
|
|
msg->errno = err;
|
|
destroy_msg(msg);
|
|
} while (!list_empty(head));
|
|
wake_up(&rpci->waitq);
|
|
}
|
|
|
|
static void
|
|
rpc_timeout_upcall_queue(void *data)
|
|
{
|
|
LIST_HEAD(free_list);
|
|
struct rpc_inode *rpci = (struct rpc_inode *)data;
|
|
struct inode *inode = &rpci->vfs_inode;
|
|
void (*destroy_msg)(struct rpc_pipe_msg *);
|
|
|
|
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);
|
|
}
|
|
|
|
int
|
|
rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
|
|
{
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
|
int res = -EPIPE;
|
|
|
|
spin_lock(&inode->i_lock);
|
|
if (rpci->ops == NULL)
|
|
goto out;
|
|
if (rpci->nreaders) {
|
|
list_add_tail(&msg->list, &rpci->pipe);
|
|
rpci->pipelen += msg->len;
|
|
res = 0;
|
|
} else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
|
|
if (list_empty(&rpci->pipe))
|
|
queue_delayed_work(rpciod_workqueue,
|
|
&rpci->queue_timeout,
|
|
RPC_UPCALL_TIMEOUT);
|
|
list_add_tail(&msg->list, &rpci->pipe);
|
|
rpci->pipelen += msg->len;
|
|
res = 0;
|
|
}
|
|
out:
|
|
spin_unlock(&inode->i_lock);
|
|
wake_up(&rpci->waitq);
|
|
return res;
|
|
}
|
|
|
|
static inline void
|
|
rpc_inode_setowner(struct inode *inode, void *private)
|
|
{
|
|
RPC_I(inode)->private = private;
|
|
}
|
|
|
|
static void
|
|
rpc_close_pipes(struct inode *inode)
|
|
{
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
|
struct rpc_pipe_ops *ops;
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
ops = rpci->ops;
|
|
if (ops != NULL) {
|
|
LIST_HEAD(free_list);
|
|
|
|
spin_lock(&inode->i_lock);
|
|
rpci->nreaders = 0;
|
|
list_splice_init(&rpci->in_upcall, &free_list);
|
|
list_splice_init(&rpci->pipe, &free_list);
|
|
rpci->pipelen = 0;
|
|
rpci->ops = NULL;
|
|
spin_unlock(&inode->i_lock);
|
|
rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
|
|
rpci->nwriters = 0;
|
|
if (ops->release_pipe)
|
|
ops->release_pipe(inode);
|
|
cancel_delayed_work(&rpci->queue_timeout);
|
|
flush_workqueue(rpciod_workqueue);
|
|
}
|
|
rpc_inode_setowner(inode, NULL);
|
|
mutex_unlock(&inode->i_mutex);
|
|
}
|
|
|
|
static struct inode *
|
|
rpc_alloc_inode(struct super_block *sb)
|
|
{
|
|
struct rpc_inode *rpci;
|
|
rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, SLAB_KERNEL);
|
|
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);
|
|
int res = -ENXIO;
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
if (rpci->ops != NULL) {
|
|
if (filp->f_mode & FMODE_READ)
|
|
rpci->nreaders ++;
|
|
if (filp->f_mode & FMODE_WRITE)
|
|
rpci->nwriters ++;
|
|
res = 0;
|
|
}
|
|
mutex_unlock(&inode->i_mutex);
|
|
return res;
|
|
}
|
|
|
|
static int
|
|
rpc_pipe_release(struct inode *inode, struct file *filp)
|
|
{
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
|
struct rpc_pipe_msg *msg;
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
if (rpci->ops == NULL)
|
|
goto out;
|
|
msg = (struct rpc_pipe_msg *)filp->private_data;
|
|
if (msg != NULL) {
|
|
spin_lock(&inode->i_lock);
|
|
msg->errno = -EAGAIN;
|
|
list_del(&msg->list);
|
|
spin_unlock(&inode->i_lock);
|
|
rpci->ops->destroy_msg(msg);
|
|
}
|
|
if (filp->f_mode & FMODE_WRITE)
|
|
rpci->nwriters --;
|
|
if (filp->f_mode & FMODE_READ) {
|
|
rpci->nreaders --;
|
|
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);
|
|
}
|
|
}
|
|
if (rpci->ops->release_pipe)
|
|
rpci->ops->release_pipe(inode);
|
|
out:
|
|
mutex_unlock(&inode->i_mutex);
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t
|
|
rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
|
|
{
|
|
struct inode *inode = filp->f_dentry->d_inode;
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
|
struct rpc_pipe_msg *msg;
|
|
int res = 0;
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
if (rpci->ops == NULL) {
|
|
res = -EPIPE;
|
|
goto out_unlock;
|
|
}
|
|
msg = filp->private_data;
|
|
if (msg == NULL) {
|
|
spin_lock(&inode->i_lock);
|
|
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;
|
|
}
|
|
spin_unlock(&inode->i_lock);
|
|
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;
|
|
spin_lock(&inode->i_lock);
|
|
list_del(&msg->list);
|
|
spin_unlock(&inode->i_lock);
|
|
rpci->ops->destroy_msg(msg);
|
|
}
|
|
out_unlock:
|
|
mutex_unlock(&inode->i_mutex);
|
|
return res;
|
|
}
|
|
|
|
static ssize_t
|
|
rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
|
|
{
|
|
struct inode *inode = filp->f_dentry->d_inode;
|
|
struct rpc_inode *rpci = RPC_I(inode);
|
|
int res;
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
res = -EPIPE;
|
|
if (rpci->ops != NULL)
|
|
res = rpci->ops->downcall(filp, buf, len);
|
|
mutex_unlock(&inode->i_mutex);
|
|
return res;
|
|
}
|
|
|
|
static unsigned int
|
|
rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
|
|
{
|
|
struct rpc_inode *rpci;
|
|
unsigned int mask = 0;
|
|
|
|
rpci = RPC_I(filp->f_dentry->d_inode);
|
|
poll_wait(filp, &rpci->waitq, wait);
|
|
|
|
mask = POLLOUT | POLLWRNORM;
|
|
if (rpci->ops == NULL)
|
|
mask |= POLLERR | POLLHUP;
|
|
if (!list_empty(&rpci->pipe))
|
|
mask |= POLLIN | POLLRDNORM;
|
|
return mask;
|
|
}
|
|
|
|
static int
|
|
rpc_pipe_ioctl(struct inode *ino, struct file *filp,
|
|
unsigned int cmd, unsigned long arg)
|
|
{
|
|
struct rpc_inode *rpci = RPC_I(filp->f_dentry->d_inode);
|
|
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;
|
|
}
|
|
}
|
|
|
|
static struct file_operations rpc_pipe_fops = {
|
|
.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);
|
|
seq_printf(m, "address: %u.%u.%u.%u\n",
|
|
NIPQUAD(clnt->cl_xprt->addr.sin_addr.s_addr));
|
|
seq_printf(m, "protocol: %s\n",
|
|
clnt->cl_xprt->prot == IPPROTO_UDP ? "udp" : "tcp");
|
|
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;
|
|
mutex_lock(&inode->i_mutex);
|
|
clnt = RPC_I(inode)->private;
|
|
if (clnt) {
|
|
atomic_inc(&clnt->cl_users);
|
|
m->private = clnt;
|
|
} else {
|
|
single_release(inode, file);
|
|
ret = -EINVAL;
|
|
}
|
|
mutex_unlock(&inode->i_mutex);
|
|
}
|
|
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);
|
|
}
|
|
|
|
static struct file_operations rpc_info_operations = {
|
|
.owner = THIS_MODULE,
|
|
.open = rpc_info_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = rpc_info_release,
|
|
};
|
|
|
|
|
|
/*
|
|
* We have a single directory with 1 node in it.
|
|
*/
|
|
enum {
|
|
RPCAUTH_Root = 1,
|
|
RPCAUTH_lockd,
|
|
RPCAUTH_mount,
|
|
RPCAUTH_nfs,
|
|
RPCAUTH_portmap,
|
|
RPCAUTH_statd,
|
|
RPCAUTH_RootEOF
|
|
};
|
|
|
|
/*
|
|
* Description of fs contents.
|
|
*/
|
|
struct rpc_filelist {
|
|
char *name;
|
|
const struct file_operations *i_fop;
|
|
int mode;
|
|
};
|
|
|
|
static 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,
|
|
},
|
|
};
|
|
|
|
enum {
|
|
RPCAUTH_info = 2,
|
|
RPCAUTH_EOF
|
|
};
|
|
|
|
static struct rpc_filelist authfiles[] = {
|
|
[RPCAUTH_info] = {
|
|
.name = "info",
|
|
.i_fop = &rpc_info_operations,
|
|
.mode = S_IFREG | S_IRUSR,
|
|
},
|
|
};
|
|
|
|
struct vfsmount *rpc_get_mount(void)
|
|
{
|
|
int err;
|
|
|
|
err = simple_pin_fs("rpc_pipefs", &rpc_mount, &rpc_mount_count);
|
|
if (err != 0)
|
|
return ERR_PTR(err);
|
|
return rpc_mount;
|
|
}
|
|
|
|
void rpc_put_mount(void)
|
|
{
|
|
simple_release_fs(&rpc_mount, &rpc_mount_count);
|
|
}
|
|
|
|
static int
|
|
rpc_lookup_parent(char *path, struct nameidata *nd)
|
|
{
|
|
if (path[0] == '\0')
|
|
return -ENOENT;
|
|
nd->mnt = rpc_get_mount();
|
|
if (IS_ERR(nd->mnt)) {
|
|
printk(KERN_WARNING "%s: %s failed to mount "
|
|
"pseudofilesystem \n", __FILE__, __FUNCTION__);
|
|
return PTR_ERR(nd->mnt);
|
|
}
|
|
mntget(nd->mnt);
|
|
nd->dentry = dget(rpc_mount->mnt_root);
|
|
nd->last_type = LAST_ROOT;
|
|
nd->flags = LOOKUP_PARENT;
|
|
nd->depth = 0;
|
|
|
|
if (path_walk(path, nd)) {
|
|
printk(KERN_WARNING "%s: %s failed to find path %s\n",
|
|
__FILE__, __FUNCTION__, path);
|
|
rpc_put_mount();
|
|
return -ENOENT;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
rpc_release_path(struct nameidata *nd)
|
|
{
|
|
path_release(nd);
|
|
rpc_put_mount();
|
|
}
|
|
|
|
static struct inode *
|
|
rpc_get_inode(struct super_block *sb, int mode)
|
|
{
|
|
struct inode *inode = new_inode(sb);
|
|
if (!inode)
|
|
return NULL;
|
|
inode->i_mode = mode;
|
|
inode->i_uid = inode->i_gid = 0;
|
|
inode->i_blksize = PAGE_CACHE_SIZE;
|
|
inode->i_blocks = 0;
|
|
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;
|
|
inode->i_nlink++;
|
|
default:
|
|
break;
|
|
}
|
|
return inode;
|
|
}
|
|
|
|
/*
|
|
* FIXME: This probably has races.
|
|
*/
|
|
static void
|
|
rpc_depopulate(struct dentry *parent)
|
|
{
|
|
struct inode *dir = parent->d_inode;
|
|
struct list_head *pos, *next;
|
|
struct dentry *dentry, *dvec[10];
|
|
int n = 0;
|
|
|
|
mutex_lock(&dir->i_mutex);
|
|
repeat:
|
|
spin_lock(&dcache_lock);
|
|
list_for_each_safe(pos, next, &parent->d_subdirs) {
|
|
dentry = list_entry(pos, struct dentry, d_u.d_child);
|
|
spin_lock(&dentry->d_lock);
|
|
if (!d_unhashed(dentry)) {
|
|
dget_locked(dentry);
|
|
__d_drop(dentry);
|
|
spin_unlock(&dentry->d_lock);
|
|
dvec[n++] = dentry;
|
|
if (n == ARRAY_SIZE(dvec))
|
|
break;
|
|
} else
|
|
spin_unlock(&dentry->d_lock);
|
|
}
|
|
spin_unlock(&dcache_lock);
|
|
if (n) {
|
|
do {
|
|
dentry = dvec[--n];
|
|
if (dentry->d_inode) {
|
|
rpc_close_pipes(dentry->d_inode);
|
|
simple_unlink(dir, dentry);
|
|
}
|
|
dput(dentry);
|
|
} while (n);
|
|
goto repeat;
|
|
}
|
|
mutex_unlock(&dir->i_mutex);
|
|
}
|
|
|
|
static int
|
|
rpc_populate(struct dentry *parent,
|
|
struct rpc_filelist *files,
|
|
int start, int eof)
|
|
{
|
|
struct inode *inode, *dir = parent->d_inode;
|
|
void *private = RPC_I(dir)->private;
|
|
struct dentry *dentry;
|
|
int mode, i;
|
|
|
|
mutex_lock(&dir->i_mutex);
|
|
for (i = start; i < eof; i++) {
|
|
dentry = d_alloc_name(parent, files[i].name);
|
|
if (!dentry)
|
|
goto out_bad;
|
|
mode = files[i].mode;
|
|
inode = rpc_get_inode(dir->i_sb, mode);
|
|
if (!inode) {
|
|
dput(dentry);
|
|
goto out_bad;
|
|
}
|
|
inode->i_ino = i;
|
|
if (files[i].i_fop)
|
|
inode->i_fop = files[i].i_fop;
|
|
if (private)
|
|
rpc_inode_setowner(inode, private);
|
|
if (S_ISDIR(mode))
|
|
dir->i_nlink++;
|
|
d_add(dentry, inode);
|
|
}
|
|
mutex_unlock(&dir->i_mutex);
|
|
return 0;
|
|
out_bad:
|
|
mutex_unlock(&dir->i_mutex);
|
|
printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
|
|
__FILE__, __FUNCTION__, parent->d_name.name);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static int
|
|
__rpc_mkdir(struct inode *dir, struct dentry *dentry)
|
|
{
|
|
struct inode *inode;
|
|
|
|
inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
|
|
if (!inode)
|
|
goto out_err;
|
|
inode->i_ino = iunique(dir->i_sb, 100);
|
|
d_instantiate(dentry, inode);
|
|
dir->i_nlink++;
|
|
inode_dir_notify(dir, DN_CREATE);
|
|
return 0;
|
|
out_err:
|
|
printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
|
|
__FILE__, __FUNCTION__, dentry->d_name.name);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static int
|
|
__rpc_rmdir(struct inode *dir, struct dentry *dentry)
|
|
{
|
|
int error;
|
|
|
|
shrink_dcache_parent(dentry);
|
|
if (dentry->d_inode)
|
|
rpc_close_pipes(dentry->d_inode);
|
|
if ((error = simple_rmdir(dir, dentry)) != 0)
|
|
return error;
|
|
if (!error) {
|
|
inode_dir_notify(dir, DN_DELETE);
|
|
d_drop(dentry);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static struct dentry *
|
|
rpc_lookup_negative(char *path, struct nameidata *nd)
|
|
{
|
|
struct dentry *dentry;
|
|
struct inode *dir;
|
|
int error;
|
|
|
|
if ((error = rpc_lookup_parent(path, nd)) != 0)
|
|
return ERR_PTR(error);
|
|
dir = nd->dentry->d_inode;
|
|
mutex_lock(&dir->i_mutex);
|
|
dentry = lookup_one_len(nd->last.name, nd->dentry, nd->last.len);
|
|
if (IS_ERR(dentry))
|
|
goto out_err;
|
|
if (dentry->d_inode) {
|
|
dput(dentry);
|
|
dentry = ERR_PTR(-EEXIST);
|
|
goto out_err;
|
|
}
|
|
return dentry;
|
|
out_err:
|
|
mutex_unlock(&dir->i_mutex);
|
|
rpc_release_path(nd);
|
|
return dentry;
|
|
}
|
|
|
|
|
|
struct dentry *
|
|
rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
|
|
{
|
|
struct nameidata nd;
|
|
struct dentry *dentry;
|
|
struct inode *dir;
|
|
int error;
|
|
|
|
dentry = rpc_lookup_negative(path, &nd);
|
|
if (IS_ERR(dentry))
|
|
return dentry;
|
|
dir = nd.dentry->d_inode;
|
|
if ((error = __rpc_mkdir(dir, dentry)) != 0)
|
|
goto err_dput;
|
|
RPC_I(dentry->d_inode)->private = rpc_client;
|
|
error = rpc_populate(dentry, authfiles,
|
|
RPCAUTH_info, RPCAUTH_EOF);
|
|
if (error)
|
|
goto err_depopulate;
|
|
out:
|
|
mutex_unlock(&dir->i_mutex);
|
|
rpc_release_path(&nd);
|
|
return dget(dentry);
|
|
err_depopulate:
|
|
rpc_depopulate(dentry);
|
|
__rpc_rmdir(dir, dentry);
|
|
err_dput:
|
|
dput(dentry);
|
|
printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
|
|
__FILE__, __FUNCTION__, path, error);
|
|
dentry = ERR_PTR(error);
|
|
goto out;
|
|
}
|
|
|
|
int
|
|
rpc_rmdir(char *path)
|
|
{
|
|
struct nameidata nd;
|
|
struct dentry *dentry;
|
|
struct inode *dir;
|
|
int error;
|
|
|
|
if ((error = rpc_lookup_parent(path, &nd)) != 0)
|
|
return error;
|
|
dir = nd.dentry->d_inode;
|
|
mutex_lock(&dir->i_mutex);
|
|
dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
|
|
if (IS_ERR(dentry)) {
|
|
error = PTR_ERR(dentry);
|
|
goto out_release;
|
|
}
|
|
rpc_depopulate(dentry);
|
|
error = __rpc_rmdir(dir, dentry);
|
|
dput(dentry);
|
|
out_release:
|
|
mutex_unlock(&dir->i_mutex);
|
|
rpc_release_path(&nd);
|
|
return error;
|
|
}
|
|
|
|
struct dentry *
|
|
rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
|
|
{
|
|
struct nameidata nd;
|
|
struct dentry *dentry;
|
|
struct inode *dir, *inode;
|
|
struct rpc_inode *rpci;
|
|
|
|
dentry = rpc_lookup_negative(path, &nd);
|
|
if (IS_ERR(dentry))
|
|
return dentry;
|
|
dir = nd.dentry->d_inode;
|
|
inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
|
|
if (!inode)
|
|
goto err_dput;
|
|
inode->i_ino = iunique(dir->i_sb, 100);
|
|
inode->i_fop = &rpc_pipe_fops;
|
|
d_instantiate(dentry, inode);
|
|
rpci = RPC_I(inode);
|
|
rpci->private = private;
|
|
rpci->flags = flags;
|
|
rpci->ops = ops;
|
|
inode_dir_notify(dir, DN_CREATE);
|
|
out:
|
|
mutex_unlock(&dir->i_mutex);
|
|
rpc_release_path(&nd);
|
|
return dget(dentry);
|
|
err_dput:
|
|
dput(dentry);
|
|
dentry = ERR_PTR(-ENOMEM);
|
|
printk(KERN_WARNING "%s: %s() failed to create pipe %s (errno = %d)\n",
|
|
__FILE__, __FUNCTION__, path, -ENOMEM);
|
|
goto out;
|
|
}
|
|
|
|
int
|
|
rpc_unlink(char *path)
|
|
{
|
|
struct nameidata nd;
|
|
struct dentry *dentry;
|
|
struct inode *dir;
|
|
int error;
|
|
|
|
if ((error = rpc_lookup_parent(path, &nd)) != 0)
|
|
return error;
|
|
dir = nd.dentry->d_inode;
|
|
mutex_lock(&dir->i_mutex);
|
|
dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
|
|
if (IS_ERR(dentry)) {
|
|
error = PTR_ERR(dentry);
|
|
goto out_release;
|
|
}
|
|
d_drop(dentry);
|
|
if (dentry->d_inode) {
|
|
rpc_close_pipes(dentry->d_inode);
|
|
error = simple_unlink(dir, dentry);
|
|
}
|
|
dput(dentry);
|
|
inode_dir_notify(dir, DN_DELETE);
|
|
out_release:
|
|
mutex_unlock(&dir->i_mutex);
|
|
rpc_release_path(&nd);
|
|
return error;
|
|
}
|
|
|
|
/*
|
|
* populate the filesystem
|
|
*/
|
|
static struct super_operations s_ops = {
|
|
.alloc_inode = rpc_alloc_inode,
|
|
.destroy_inode = rpc_destroy_inode,
|
|
.statfs = simple_statfs,
|
|
};
|
|
|
|
#define RPCAUTH_GSSMAGIC 0x67596969
|
|
|
|
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;
|
|
}
|
|
if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
|
|
goto out;
|
|
sb->s_root = root;
|
|
return 0;
|
|
out:
|
|
d_genocide(root);
|
|
dput(root);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static int
|
|
rpc_get_sb(struct file_system_type *fs_type,
|
|
int flags, const char *dev_name, void *data, struct vfsmount *mnt)
|
|
{
|
|
return get_sb_single(fs_type, flags, data, rpc_fill_super, mnt);
|
|
}
|
|
|
|
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
|
|
init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
|
|
{
|
|
struct rpc_inode *rpci = (struct rpc_inode *) foo;
|
|
|
|
if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
|
|
SLAB_CTOR_CONSTRUCTOR) {
|
|
inode_init_once(&rpci->vfs_inode);
|
|
rpci->private = NULL;
|
|
rpci->nreaders = 0;
|
|
rpci->nwriters = 0;
|
|
INIT_LIST_HEAD(&rpci->in_upcall);
|
|
INIT_LIST_HEAD(&rpci->pipe);
|
|
rpci->pipelen = 0;
|
|
init_waitqueue_head(&rpci->waitq);
|
|
INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
|
|
rpci->ops = NULL;
|
|
}
|
|
}
|
|
|
|
int register_rpc_pipefs(void)
|
|
{
|
|
rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
|
|
sizeof(struct rpc_inode),
|
|
0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
|
|
SLAB_MEM_SPREAD),
|
|
init_once, NULL);
|
|
if (!rpc_inode_cachep)
|
|
return -ENOMEM;
|
|
register_filesystem(&rpc_pipe_fs_type);
|
|
return 0;
|
|
}
|
|
|
|
void unregister_rpc_pipefs(void)
|
|
{
|
|
if (kmem_cache_destroy(rpc_inode_cachep))
|
|
printk(KERN_WARNING "RPC: unable to free inode cache\n");
|
|
unregister_filesystem(&rpc_pipe_fs_type);
|
|
}
|