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;
437 if (path_walk(path, nd)) {
438 printk(KERN_WARNING "%s: %s failed to find path %s\n",
439 __FILE__, __FUNCTION__, path);
447 rpc_release_path(struct nameidata *nd)
453 static struct inode *
454 rpc_get_inode(struct super_block *sb, int mode)
456 struct inode *inode = new_inode(sb);
459 inode->i_mode = mode;
460 inode->i_uid = inode->i_gid = 0;
461 inode->i_blksize = PAGE_CACHE_SIZE;
463 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
464 switch(mode & S_IFMT) {
466 inode->i_fop = &simple_dir_operations;
467 inode->i_op = &simple_dir_inode_operations;
476 * FIXME: This probably has races.
479 rpc_depopulate(struct dentry *parent)
481 struct inode *dir = parent->d_inode;
482 struct list_head *pos, *next;
483 struct dentry *dentry, *dvec[10];
488 spin_lock(&dcache_lock);
489 list_for_each_safe(pos, next, &parent->d_subdirs) {
490 dentry = list_entry(pos, struct dentry, d_child);
491 spin_lock(&dentry->d_lock);
492 if (!d_unhashed(dentry)) {
495 spin_unlock(&dentry->d_lock);
497 if (n == ARRAY_SIZE(dvec))
500 spin_unlock(&dentry->d_lock);
502 spin_unlock(&dcache_lock);
506 if (dentry->d_inode) {
507 rpc_close_pipes(dentry->d_inode);
508 rpc_inode_setowner(dentry->d_inode, NULL);
509 simple_unlink(dir, dentry);
519 rpc_populate(struct dentry *parent,
520 struct rpc_filelist *files,
523 struct inode *inode, *dir = parent->d_inode;
524 void *private = RPC_I(dir)->private;
526 struct dentry *dentry;
530 for (i = start; i < eof; i++) {
531 name.name = files[i].name;
532 name.len = strlen(name.name);
533 name.hash = full_name_hash(name.name, name.len);
534 dentry = d_alloc(parent, &name);
537 mode = files[i].mode;
538 inode = rpc_get_inode(dir->i_sb, mode);
545 inode->i_fop = files[i].i_fop;
547 rpc_inode_setowner(inode, private);
550 d_add(dentry, inode);
556 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
557 __FILE__, __FUNCTION__, parent->d_name.name);
562 __rpc_mkdir(struct inode *dir, struct dentry *dentry)
566 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
569 inode->i_ino = iunique(dir->i_sb, 100);
570 d_instantiate(dentry, inode);
572 inode_dir_notify(dir, DN_CREATE);
576 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
577 __FILE__, __FUNCTION__, dentry->d_name.name);
582 __rpc_rmdir(struct inode *dir, struct dentry *dentry)
586 shrink_dcache_parent(dentry);
587 if (dentry->d_inode) {
588 rpc_close_pipes(dentry->d_inode);
589 rpc_inode_setowner(dentry->d_inode, NULL);
591 if ((error = simple_rmdir(dir, dentry)) != 0)
594 inode_dir_notify(dir, DN_DELETE);
602 rpc_lookup_negative(char *path, struct nameidata *nd)
604 struct dentry *dentry;
608 if ((error = rpc_lookup_parent(path, nd)) != 0)
609 return ERR_PTR(error);
610 dir = nd->dentry->d_inode;
612 dentry = lookup_hash(&nd->last, nd->dentry);
615 if (dentry->d_inode) {
617 dentry = ERR_PTR(-EEXIST);
623 rpc_release_path(nd);
629 rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
632 struct dentry *dentry;
636 dentry = rpc_lookup_negative(path, &nd);
639 dir = nd.dentry->d_inode;
640 if ((error = __rpc_mkdir(dir, dentry)) != 0)
642 RPC_I(dentry->d_inode)->private = rpc_client;
643 error = rpc_populate(dentry, authfiles,
644 RPCAUTH_info, RPCAUTH_EOF);
649 rpc_release_path(&nd);
652 rpc_depopulate(dentry);
653 __rpc_rmdir(dir, dentry);
656 printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
657 __FILE__, __FUNCTION__, path, error);
658 dentry = ERR_PTR(error);
663 rpc_rmdir(char *path)
666 struct dentry *dentry;
670 if ((error = rpc_lookup_parent(path, &nd)) != 0)
672 dir = nd.dentry->d_inode;
674 dentry = lookup_hash(&nd.last, nd.dentry);
675 if (IS_ERR(dentry)) {
676 error = PTR_ERR(dentry);
679 rpc_depopulate(dentry);
680 error = __rpc_rmdir(dir, dentry);
684 rpc_release_path(&nd);
689 rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
692 struct dentry *dentry;
693 struct inode *dir, *inode;
694 struct rpc_inode *rpci;
696 dentry = rpc_lookup_negative(path, &nd);
699 dir = nd.dentry->d_inode;
700 inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
703 inode->i_ino = iunique(dir->i_sb, 100);
704 inode->i_fop = &rpc_pipe_fops;
705 d_instantiate(dentry, inode);
707 rpci->private = private;
710 inode_dir_notify(dir, DN_CREATE);
713 rpc_release_path(&nd);
717 dentry = ERR_PTR(-ENOMEM);
718 printk(KERN_WARNING "%s: %s() failed to create pipe %s (errno = %d)\n",
719 __FILE__, __FUNCTION__, path, -ENOMEM);
724 rpc_unlink(char *path)
727 struct dentry *dentry;
731 if ((error = rpc_lookup_parent(path, &nd)) != 0)
733 dir = nd.dentry->d_inode;
735 dentry = lookup_hash(&nd.last, nd.dentry);
736 if (IS_ERR(dentry)) {
737 error = PTR_ERR(dentry);
741 if (dentry->d_inode) {
742 rpc_close_pipes(dentry->d_inode);
743 rpc_inode_setowner(dentry->d_inode, NULL);
744 error = simple_unlink(dir, dentry);
747 inode_dir_notify(dir, DN_DELETE);
750 rpc_release_path(&nd);
755 * populate the filesystem
757 static struct super_operations s_ops = {
758 .alloc_inode = rpc_alloc_inode,
759 .destroy_inode = rpc_destroy_inode,
760 .statfs = simple_statfs,
763 #define RPCAUTH_GSSMAGIC 0x67596969
766 rpc_fill_super(struct super_block *sb, void *data, int silent)
771 sb->s_blocksize = PAGE_CACHE_SIZE;
772 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
773 sb->s_magic = RPCAUTH_GSSMAGIC;
776 inode = rpc_get_inode(sb, S_IFDIR | 0755);
779 root = d_alloc_root(inode);
784 if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
794 static struct super_block *
795 rpc_get_sb(struct file_system_type *fs_type,
796 int flags, const char *dev_name, void *data)
798 return get_sb_single(fs_type, flags, data, rpc_fill_super);
801 static struct file_system_type rpc_pipe_fs_type = {
802 .owner = THIS_MODULE,
803 .name = "rpc_pipefs",
804 .get_sb = rpc_get_sb,
805 .kill_sb = kill_litter_super,
809 init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
811 struct rpc_inode *rpci = (struct rpc_inode *) foo;
813 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
814 SLAB_CTOR_CONSTRUCTOR) {
815 inode_init_once(&rpci->vfs_inode);
816 rpci->private = NULL;
819 INIT_LIST_HEAD(&rpci->in_upcall);
820 INIT_LIST_HEAD(&rpci->pipe);
822 init_waitqueue_head(&rpci->waitq);
823 INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
828 int register_rpc_pipefs(void)
830 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
831 sizeof(struct rpc_inode),
832 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
834 if (!rpc_inode_cachep)
836 register_filesystem(&rpc_pipe_fs_type);
840 void unregister_rpc_pipefs(void)
842 if (kmem_cache_destroy(rpc_inode_cachep))
843 printk(KERN_WARNING "RPC: unable to free inode cache\n");
844 unregister_filesystem(&rpc_pipe_fs_type);