2 * net/sunrpc/rpc_pipe.c
4 * Userland/kernel interface for rpcauth_gss.
5 * Code shamelessly plagiarized from fs/nfsd/nfsctl.c
6 * and fs/driverfs/inode.c
8 * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
11 #include <linux/config.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/string.h>
15 #include <linux/pagemap.h>
16 #include <linux/mount.h>
17 #include <linux/namei.h>
18 #include <linux/dnotify.h>
19 #include <linux/kernel.h>
21 #include <asm/ioctls.h>
23 #include <linux/poll.h>
24 #include <linux/wait.h>
25 #include <linux/seq_file.h>
27 #include <linux/sunrpc/clnt.h>
28 #include <linux/workqueue.h>
29 #include <linux/sunrpc/rpc_pipe_fs.h>
31 static struct vfsmount *rpc_mount;
32 static int rpc_mount_count;
34 static struct file_system_type rpc_pipe_fs_type;
37 static kmem_cache_t *rpc_inode_cachep;
39 #define RPC_UPCALL_TIMEOUT (30*HZ)
42 __rpc_purge_upcall(struct inode *inode, int err)
44 struct rpc_inode *rpci = RPC_I(inode);
45 struct rpc_pipe_msg *msg;
47 while (!list_empty(&rpci->pipe)) {
48 msg = list_entry(rpci->pipe.next, struct rpc_pipe_msg, list);
49 list_del_init(&msg->list);
51 rpci->ops->destroy_msg(msg);
53 while (!list_empty(&rpci->in_upcall)) {
54 msg = list_entry(rpci->pipe.next, struct rpc_pipe_msg, list);
55 list_del_init(&msg->list);
57 rpci->ops->destroy_msg(msg);
60 wake_up(&rpci->waitq);
64 rpc_timeout_upcall_queue(void *data)
66 struct rpc_inode *rpci = (struct rpc_inode *)data;
67 struct inode *inode = &rpci->vfs_inode;
70 if (rpci->nreaders == 0 && !list_empty(&rpci->pipe))
71 __rpc_purge_upcall(inode, -ETIMEDOUT);
76 rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
78 struct rpc_inode *rpci = RPC_I(inode);
83 list_add_tail(&msg->list, &rpci->pipe);
84 rpci->pipelen += msg->len;
85 } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
86 if (list_empty(&rpci->pipe))
87 schedule_delayed_work(&rpci->queue_timeout,
89 list_add_tail(&msg->list, &rpci->pipe);
90 rpci->pipelen += msg->len;
94 wake_up(&rpci->waitq);
99 rpc_close_pipes(struct inode *inode)
101 struct rpc_inode *rpci = RPC_I(inode);
103 cancel_delayed_work(&rpci->queue_timeout);
104 flush_scheduled_work();
106 if (rpci->ops != NULL) {
108 __rpc_purge_upcall(inode, -EPIPE);
110 if (rpci->ops->release_pipe)
111 rpci->ops->release_pipe(inode);
118 rpc_inode_setowner(struct inode *inode, void *private)
120 RPC_I(inode)->private = private;
123 static struct inode *
124 rpc_alloc_inode(struct super_block *sb)
126 struct rpc_inode *rpci;
127 rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, SLAB_KERNEL);
130 return &rpci->vfs_inode;
134 rpc_destroy_inode(struct inode *inode)
136 kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
140 rpc_pipe_open(struct inode *inode, struct file *filp)
142 struct rpc_inode *rpci = RPC_I(inode);
146 if (rpci->ops != NULL) {
147 if (filp->f_mode & FMODE_READ)
149 if (filp->f_mode & FMODE_WRITE)
158 rpc_pipe_release(struct inode *inode, struct file *filp)
160 struct rpc_inode *rpci = RPC_I(filp->f_dentry->d_inode);
161 struct rpc_pipe_msg *msg;
164 if (rpci->ops == NULL)
166 msg = (struct rpc_pipe_msg *)filp->private_data;
169 list_del_init(&msg->list);
170 rpci->ops->destroy_msg(msg);
172 if (filp->f_mode & FMODE_WRITE)
174 if (filp->f_mode & FMODE_READ)
177 __rpc_purge_upcall(inode, -EPIPE);
178 if (rpci->ops->release_pipe)
179 rpci->ops->release_pipe(inode);
186 rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
188 struct inode *inode = filp->f_dentry->d_inode;
189 struct rpc_inode *rpci = RPC_I(inode);
190 struct rpc_pipe_msg *msg;
194 if (rpci->ops == NULL) {
198 msg = filp->private_data;
200 if (!list_empty(&rpci->pipe)) {
201 msg = list_entry(rpci->pipe.next,
204 list_move(&msg->list, &rpci->in_upcall);
205 rpci->pipelen -= msg->len;
206 filp->private_data = msg;
212 /* NOTE: it is up to the callback to update msg->copied */
213 res = rpci->ops->upcall(filp, msg, buf, len);
214 if (res < 0 || msg->len == msg->copied) {
215 filp->private_data = NULL;
216 list_del_init(&msg->list);
217 rpci->ops->destroy_msg(msg);
225 rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
227 struct inode *inode = filp->f_dentry->d_inode;
228 struct rpc_inode *rpci = RPC_I(inode);
233 if (rpci->ops != NULL)
234 res = rpci->ops->downcall(filp, buf, len);
240 rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
242 struct rpc_inode *rpci;
243 unsigned int mask = 0;
245 rpci = RPC_I(filp->f_dentry->d_inode);
246 poll_wait(filp, &rpci->waitq, wait);
248 mask = POLLOUT | POLLWRNORM;
249 if (rpci->ops == NULL)
250 mask |= POLLERR | POLLHUP;
251 if (!list_empty(&rpci->pipe))
252 mask |= POLLIN | POLLRDNORM;
257 rpc_pipe_ioctl(struct inode *ino, struct file *filp,
258 unsigned int cmd, unsigned long arg)
260 struct rpc_inode *rpci = RPC_I(filp->f_dentry->d_inode);
265 if (rpci->ops == NULL)
268 if (filp->private_data) {
269 struct rpc_pipe_msg *msg;
270 msg = (struct rpc_pipe_msg *)filp->private_data;
271 len += msg->len - msg->copied;
273 return put_user(len, (int __user *)arg);
279 struct inode_operations rpc_pipe_iops = {
280 .lookup = simple_lookup,
284 struct file_operations rpc_pipe_fops = {
285 .owner = THIS_MODULE,
287 .read = rpc_pipe_read,
288 .write = rpc_pipe_write,
289 .poll = rpc_pipe_poll,
290 .ioctl = rpc_pipe_ioctl,
291 .open = rpc_pipe_open,
292 .release = rpc_pipe_release,
296 rpc_show_info(struct seq_file *m, void *v)
298 struct rpc_clnt *clnt = m->private;
300 seq_printf(m, "RPC server: %s\n", clnt->cl_server);
301 seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
302 clnt->cl_prog, clnt->cl_vers);
303 seq_printf(m, "address: %u.%u.%u.%u\n",
304 NIPQUAD(clnt->cl_xprt->addr.sin_addr.s_addr));
305 seq_printf(m, "protocol: %s\n",
306 clnt->cl_xprt->prot == IPPROTO_UDP ? "udp" : "tcp");
311 rpc_info_open(struct inode *inode, struct file *file)
313 struct rpc_clnt *clnt;
314 int ret = single_open(file, rpc_show_info, NULL);
317 struct seq_file *m = file->private_data;
319 clnt = RPC_I(inode)->private;
321 atomic_inc(&clnt->cl_users);
324 single_release(inode, file);
333 rpc_info_release(struct inode *inode, struct file *file)
335 struct seq_file *m = file->private_data;
336 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
339 rpc_release_client(clnt);
340 return single_release(inode, file);
343 static struct file_operations rpc_info_operations = {
344 .owner = THIS_MODULE,
345 .open = rpc_info_open,
348 .release = rpc_info_release,
353 * We have a single directory with 1 node in it.
366 * Description of fs contents.
368 struct rpc_filelist {
370 struct file_operations *i_fop;
374 static struct rpc_filelist files[] = {
377 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
381 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
385 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
387 [RPCAUTH_portmap] = {
389 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
393 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
402 static struct rpc_filelist authfiles[] = {
405 .i_fop = &rpc_info_operations,
406 .mode = S_IFREG | S_IRUSR,
413 return simple_pin_fs("rpc_pipefs", &rpc_mount, &rpc_mount_count);
419 simple_release_fs(&rpc_mount, &rpc_mount_count);
423 rpc_lookup_parent(char *path, struct nameidata *nd)
427 if (rpc_get_mount()) {
428 printk(KERN_WARNING "%s: %s failed to mount "
429 "pseudofilesystem \n", __FILE__, __FUNCTION__);
432 nd->mnt = mntget(rpc_mount);
433 nd->dentry = dget(rpc_mount->mnt_root);
434 nd->last_type = LAST_ROOT;
435 nd->flags = LOOKUP_PARENT;
438 if (path_walk(path, nd)) {
439 printk(KERN_WARNING "%s: %s failed to find path %s\n",
440 __FILE__, __FUNCTION__, path);
448 rpc_release_path(struct nameidata *nd)
454 static struct inode *
455 rpc_get_inode(struct super_block *sb, int mode)
457 struct inode *inode = new_inode(sb);
460 inode->i_mode = mode;
461 inode->i_uid = inode->i_gid = 0;
462 inode->i_blksize = PAGE_CACHE_SIZE;
464 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
465 switch(mode & S_IFMT) {
467 inode->i_fop = &simple_dir_operations;
468 inode->i_op = &simple_dir_inode_operations;
477 * FIXME: This probably has races.
480 rpc_depopulate(struct dentry *parent)
482 struct inode *dir = parent->d_inode;
483 struct list_head *pos, *next;
484 struct dentry *dentry, *dvec[10];
489 spin_lock(&dcache_lock);
490 list_for_each_safe(pos, next, &parent->d_subdirs) {
491 dentry = list_entry(pos, struct dentry, d_child);
492 spin_lock(&dentry->d_lock);
493 if (!d_unhashed(dentry)) {
496 spin_unlock(&dentry->d_lock);
498 if (n == ARRAY_SIZE(dvec))
501 spin_unlock(&dentry->d_lock);
503 spin_unlock(&dcache_lock);
507 if (dentry->d_inode) {
508 rpc_close_pipes(dentry->d_inode);
509 rpc_inode_setowner(dentry->d_inode, NULL);
510 simple_unlink(dir, dentry);
520 rpc_populate(struct dentry *parent,
521 struct rpc_filelist *files,
524 struct inode *inode, *dir = parent->d_inode;
525 void *private = RPC_I(dir)->private;
526 struct dentry *dentry;
530 for (i = start; i < eof; i++) {
531 dentry = d_alloc_name(parent, files[i].name);
534 mode = files[i].mode;
535 inode = rpc_get_inode(dir->i_sb, mode);
542 inode->i_fop = files[i].i_fop;
544 rpc_inode_setowner(inode, private);
547 d_add(dentry, inode);
553 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
554 __FILE__, __FUNCTION__, parent->d_name.name);
559 __rpc_mkdir(struct inode *dir, struct dentry *dentry)
563 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
566 inode->i_ino = iunique(dir->i_sb, 100);
567 d_instantiate(dentry, inode);
569 inode_dir_notify(dir, DN_CREATE);
573 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
574 __FILE__, __FUNCTION__, dentry->d_name.name);
579 __rpc_rmdir(struct inode *dir, struct dentry *dentry)
583 shrink_dcache_parent(dentry);
584 if (dentry->d_inode) {
585 rpc_close_pipes(dentry->d_inode);
586 rpc_inode_setowner(dentry->d_inode, NULL);
588 if ((error = simple_rmdir(dir, dentry)) != 0)
591 inode_dir_notify(dir, DN_DELETE);
599 rpc_lookup_negative(char *path, struct nameidata *nd)
601 struct dentry *dentry;
605 if ((error = rpc_lookup_parent(path, nd)) != 0)
606 return ERR_PTR(error);
607 dir = nd->dentry->d_inode;
609 dentry = lookup_hash(&nd->last, nd->dentry);
612 if (dentry->d_inode) {
614 dentry = ERR_PTR(-EEXIST);
620 rpc_release_path(nd);
626 rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
629 struct dentry *dentry;
633 dentry = rpc_lookup_negative(path, &nd);
636 dir = nd.dentry->d_inode;
637 if ((error = __rpc_mkdir(dir, dentry)) != 0)
639 RPC_I(dentry->d_inode)->private = rpc_client;
640 error = rpc_populate(dentry, authfiles,
641 RPCAUTH_info, RPCAUTH_EOF);
646 rpc_release_path(&nd);
649 rpc_depopulate(dentry);
650 __rpc_rmdir(dir, dentry);
653 printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
654 __FILE__, __FUNCTION__, path, error);
655 dentry = ERR_PTR(error);
660 rpc_rmdir(char *path)
663 struct dentry *dentry;
667 if ((error = rpc_lookup_parent(path, &nd)) != 0)
669 dir = nd.dentry->d_inode;
671 dentry = lookup_hash(&nd.last, nd.dentry);
672 if (IS_ERR(dentry)) {
673 error = PTR_ERR(dentry);
676 rpc_depopulate(dentry);
677 error = __rpc_rmdir(dir, dentry);
681 rpc_release_path(&nd);
686 rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
689 struct dentry *dentry;
690 struct inode *dir, *inode;
691 struct rpc_inode *rpci;
693 dentry = rpc_lookup_negative(path, &nd);
696 dir = nd.dentry->d_inode;
697 inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
700 inode->i_ino = iunique(dir->i_sb, 100);
701 inode->i_fop = &rpc_pipe_fops;
702 d_instantiate(dentry, inode);
704 rpci->private = private;
707 inode_dir_notify(dir, DN_CREATE);
710 rpc_release_path(&nd);
714 dentry = ERR_PTR(-ENOMEM);
715 printk(KERN_WARNING "%s: %s() failed to create pipe %s (errno = %d)\n",
716 __FILE__, __FUNCTION__, path, -ENOMEM);
721 rpc_unlink(char *path)
724 struct dentry *dentry;
728 if ((error = rpc_lookup_parent(path, &nd)) != 0)
730 dir = nd.dentry->d_inode;
732 dentry = lookup_hash(&nd.last, nd.dentry);
733 if (IS_ERR(dentry)) {
734 error = PTR_ERR(dentry);
738 if (dentry->d_inode) {
739 rpc_close_pipes(dentry->d_inode);
740 rpc_inode_setowner(dentry->d_inode, NULL);
741 error = simple_unlink(dir, dentry);
744 inode_dir_notify(dir, DN_DELETE);
747 rpc_release_path(&nd);
752 * populate the filesystem
754 static struct super_operations s_ops = {
755 .alloc_inode = rpc_alloc_inode,
756 .destroy_inode = rpc_destroy_inode,
757 .statfs = simple_statfs,
760 #define RPCAUTH_GSSMAGIC 0x67596969
763 rpc_fill_super(struct super_block *sb, void *data, int silent)
768 sb->s_blocksize = PAGE_CACHE_SIZE;
769 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
770 sb->s_magic = RPCAUTH_GSSMAGIC;
773 inode = rpc_get_inode(sb, S_IFDIR | 0755);
776 root = d_alloc_root(inode);
781 if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
791 static struct super_block *
792 rpc_get_sb(struct file_system_type *fs_type,
793 int flags, const char *dev_name, void *data)
795 return get_sb_single(fs_type, flags, data, rpc_fill_super);
798 static struct file_system_type rpc_pipe_fs_type = {
799 .owner = THIS_MODULE,
800 .name = "rpc_pipefs",
801 .get_sb = rpc_get_sb,
802 .kill_sb = kill_litter_super,
806 init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
808 struct rpc_inode *rpci = (struct rpc_inode *) foo;
810 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
811 SLAB_CTOR_CONSTRUCTOR) {
812 inode_init_once(&rpci->vfs_inode);
813 rpci->private = NULL;
816 INIT_LIST_HEAD(&rpci->in_upcall);
817 INIT_LIST_HEAD(&rpci->pipe);
819 init_waitqueue_head(&rpci->waitq);
820 INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
825 int register_rpc_pipefs(void)
827 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
828 sizeof(struct rpc_inode),
829 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
831 if (!rpc_inode_cachep)
833 register_filesystem(&rpc_pipe_fs_type);
837 void unregister_rpc_pipefs(void)
839 if (kmem_cache_destroy(rpc_inode_cachep))
840 printk(KERN_WARNING "RPC: unable to free inode cache\n");
841 unregister_filesystem(&rpc_pipe_fs_type);