2 * net/sunrpc/rpc_pipe.c
4 * Userland/kernel interface for rpcauth_gss.
5 * Code shamelessly plagiarized from fs/nfsd/nfsctl.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 __read_mostly
;
32 static int rpc_mount_count
;
34 static struct file_system_type rpc_pipe_fs_type
;
37 static kmem_cache_t
*rpc_inode_cachep __read_mostly
;
39 #define RPC_UPCALL_TIMEOUT (30*HZ)
41 static void rpc_purge_list(struct rpc_inode
*rpci
, struct list_head
*head
,
42 void (*destroy_msg
)(struct rpc_pipe_msg
*), int err
)
44 struct rpc_pipe_msg
*msg
;
49 msg
= list_entry(head
->next
, struct rpc_pipe_msg
, list
);
53 } while (!list_empty(head
));
54 wake_up(&rpci
->waitq
);
58 rpc_timeout_upcall_queue(void *data
)
61 struct rpc_inode
*rpci
= (struct rpc_inode
*)data
;
62 struct inode
*inode
= &rpci
->vfs_inode
;
63 void (*destroy_msg
)(struct rpc_pipe_msg
*);
65 spin_lock(&inode
->i_lock
);
66 if (rpci
->ops
== NULL
) {
67 spin_unlock(&inode
->i_lock
);
70 destroy_msg
= rpci
->ops
->destroy_msg
;
71 if (rpci
->nreaders
== 0) {
72 list_splice_init(&rpci
->pipe
, &free_list
);
75 spin_unlock(&inode
->i_lock
);
76 rpc_purge_list(rpci
, &free_list
, destroy_msg
, -ETIMEDOUT
);
80 rpc_queue_upcall(struct inode
*inode
, struct rpc_pipe_msg
*msg
)
82 struct rpc_inode
*rpci
= RPC_I(inode
);
85 spin_lock(&inode
->i_lock
);
86 if (rpci
->ops
== NULL
)
89 list_add_tail(&msg
->list
, &rpci
->pipe
);
90 rpci
->pipelen
+= msg
->len
;
92 } else if (rpci
->flags
& RPC_PIPE_WAIT_FOR_OPEN
) {
93 if (list_empty(&rpci
->pipe
))
94 queue_delayed_work(rpciod_workqueue
,
97 list_add_tail(&msg
->list
, &rpci
->pipe
);
98 rpci
->pipelen
+= msg
->len
;
102 spin_unlock(&inode
->i_lock
);
103 wake_up(&rpci
->waitq
);
108 rpc_inode_setowner(struct inode
*inode
, void *private)
110 RPC_I(inode
)->private = private;
114 rpc_close_pipes(struct inode
*inode
)
116 struct rpc_inode
*rpci
= RPC_I(inode
);
117 struct rpc_pipe_ops
*ops
;
119 mutex_lock(&inode
->i_mutex
);
122 LIST_HEAD(free_list
);
124 spin_lock(&inode
->i_lock
);
126 list_splice_init(&rpci
->in_upcall
, &free_list
);
127 list_splice_init(&rpci
->pipe
, &free_list
);
130 spin_unlock(&inode
->i_lock
);
131 rpc_purge_list(rpci
, &free_list
, ops
->destroy_msg
, -EPIPE
);
133 if (ops
->release_pipe
)
134 ops
->release_pipe(inode
);
135 cancel_delayed_work(&rpci
->queue_timeout
);
136 flush_workqueue(rpciod_workqueue
);
138 rpc_inode_setowner(inode
, NULL
);
139 mutex_unlock(&inode
->i_mutex
);
142 static struct inode
*
143 rpc_alloc_inode(struct super_block
*sb
)
145 struct rpc_inode
*rpci
;
146 rpci
= (struct rpc_inode
*)kmem_cache_alloc(rpc_inode_cachep
, SLAB_KERNEL
);
149 return &rpci
->vfs_inode
;
153 rpc_destroy_inode(struct inode
*inode
)
155 kmem_cache_free(rpc_inode_cachep
, RPC_I(inode
));
159 rpc_pipe_open(struct inode
*inode
, struct file
*filp
)
161 struct rpc_inode
*rpci
= RPC_I(inode
);
164 mutex_lock(&inode
->i_mutex
);
165 if (rpci
->ops
!= NULL
) {
166 if (filp
->f_mode
& FMODE_READ
)
168 if (filp
->f_mode
& FMODE_WRITE
)
172 mutex_unlock(&inode
->i_mutex
);
177 rpc_pipe_release(struct inode
*inode
, struct file
*filp
)
179 struct rpc_inode
*rpci
= RPC_I(inode
);
180 struct rpc_pipe_msg
*msg
;
182 mutex_lock(&inode
->i_mutex
);
183 if (rpci
->ops
== NULL
)
185 msg
= (struct rpc_pipe_msg
*)filp
->private_data
;
187 spin_lock(&inode
->i_lock
);
188 msg
->errno
= -EAGAIN
;
189 list_del(&msg
->list
);
190 spin_unlock(&inode
->i_lock
);
191 rpci
->ops
->destroy_msg(msg
);
193 if (filp
->f_mode
& FMODE_WRITE
)
195 if (filp
->f_mode
& FMODE_READ
) {
197 if (rpci
->nreaders
== 0) {
198 LIST_HEAD(free_list
);
199 spin_lock(&inode
->i_lock
);
200 list_splice_init(&rpci
->pipe
, &free_list
);
202 spin_unlock(&inode
->i_lock
);
203 rpc_purge_list(rpci
, &free_list
,
204 rpci
->ops
->destroy_msg
, -EAGAIN
);
207 if (rpci
->ops
->release_pipe
)
208 rpci
->ops
->release_pipe(inode
);
210 mutex_unlock(&inode
->i_mutex
);
215 rpc_pipe_read(struct file
*filp
, char __user
*buf
, size_t len
, loff_t
*offset
)
217 struct inode
*inode
= filp
->f_dentry
->d_inode
;
218 struct rpc_inode
*rpci
= RPC_I(inode
);
219 struct rpc_pipe_msg
*msg
;
222 mutex_lock(&inode
->i_mutex
);
223 if (rpci
->ops
== NULL
) {
227 msg
= filp
->private_data
;
229 spin_lock(&inode
->i_lock
);
230 if (!list_empty(&rpci
->pipe
)) {
231 msg
= list_entry(rpci
->pipe
.next
,
234 list_move(&msg
->list
, &rpci
->in_upcall
);
235 rpci
->pipelen
-= msg
->len
;
236 filp
->private_data
= msg
;
239 spin_unlock(&inode
->i_lock
);
243 /* NOTE: it is up to the callback to update msg->copied */
244 res
= rpci
->ops
->upcall(filp
, msg
, buf
, len
);
245 if (res
< 0 || msg
->len
== msg
->copied
) {
246 filp
->private_data
= NULL
;
247 spin_lock(&inode
->i_lock
);
248 list_del(&msg
->list
);
249 spin_unlock(&inode
->i_lock
);
250 rpci
->ops
->destroy_msg(msg
);
253 mutex_unlock(&inode
->i_mutex
);
258 rpc_pipe_write(struct file
*filp
, const char __user
*buf
, size_t len
, loff_t
*offset
)
260 struct inode
*inode
= filp
->f_dentry
->d_inode
;
261 struct rpc_inode
*rpci
= RPC_I(inode
);
264 mutex_lock(&inode
->i_mutex
);
266 if (rpci
->ops
!= NULL
)
267 res
= rpci
->ops
->downcall(filp
, buf
, len
);
268 mutex_unlock(&inode
->i_mutex
);
273 rpc_pipe_poll(struct file
*filp
, struct poll_table_struct
*wait
)
275 struct rpc_inode
*rpci
;
276 unsigned int mask
= 0;
278 rpci
= RPC_I(filp
->f_dentry
->d_inode
);
279 poll_wait(filp
, &rpci
->waitq
, wait
);
281 mask
= POLLOUT
| POLLWRNORM
;
282 if (rpci
->ops
== NULL
)
283 mask
|= POLLERR
| POLLHUP
;
284 if (!list_empty(&rpci
->pipe
))
285 mask
|= POLLIN
| POLLRDNORM
;
290 rpc_pipe_ioctl(struct inode
*ino
, struct file
*filp
,
291 unsigned int cmd
, unsigned long arg
)
293 struct rpc_inode
*rpci
= RPC_I(filp
->f_dentry
->d_inode
);
298 if (rpci
->ops
== NULL
)
301 if (filp
->private_data
) {
302 struct rpc_pipe_msg
*msg
;
303 msg
= (struct rpc_pipe_msg
*)filp
->private_data
;
304 len
+= msg
->len
- msg
->copied
;
306 return put_user(len
, (int __user
*)arg
);
312 static struct file_operations rpc_pipe_fops
= {
313 .owner
= THIS_MODULE
,
315 .read
= rpc_pipe_read
,
316 .write
= rpc_pipe_write
,
317 .poll
= rpc_pipe_poll
,
318 .ioctl
= rpc_pipe_ioctl
,
319 .open
= rpc_pipe_open
,
320 .release
= rpc_pipe_release
,
324 rpc_show_info(struct seq_file
*m
, void *v
)
326 struct rpc_clnt
*clnt
= m
->private;
328 seq_printf(m
, "RPC server: %s\n", clnt
->cl_server
);
329 seq_printf(m
, "service: %s (%d) version %d\n", clnt
->cl_protname
,
330 clnt
->cl_prog
, clnt
->cl_vers
);
331 seq_printf(m
, "address: %u.%u.%u.%u\n",
332 NIPQUAD(clnt
->cl_xprt
->addr
.sin_addr
.s_addr
));
333 seq_printf(m
, "protocol: %s\n",
334 clnt
->cl_xprt
->prot
== IPPROTO_UDP
? "udp" : "tcp");
339 rpc_info_open(struct inode
*inode
, struct file
*file
)
341 struct rpc_clnt
*clnt
;
342 int ret
= single_open(file
, rpc_show_info
, NULL
);
345 struct seq_file
*m
= file
->private_data
;
346 mutex_lock(&inode
->i_mutex
);
347 clnt
= RPC_I(inode
)->private;
349 atomic_inc(&clnt
->cl_users
);
352 single_release(inode
, file
);
355 mutex_unlock(&inode
->i_mutex
);
361 rpc_info_release(struct inode
*inode
, struct file
*file
)
363 struct seq_file
*m
= file
->private_data
;
364 struct rpc_clnt
*clnt
= (struct rpc_clnt
*)m
->private;
367 rpc_release_client(clnt
);
368 return single_release(inode
, file
);
371 static struct file_operations rpc_info_operations
= {
372 .owner
= THIS_MODULE
,
373 .open
= rpc_info_open
,
376 .release
= rpc_info_release
,
381 * We have a single directory with 1 node in it.
394 * Description of fs contents.
396 struct rpc_filelist
{
398 struct file_operations
*i_fop
;
402 static struct rpc_filelist files
[] = {
405 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
409 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
413 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
415 [RPCAUTH_portmap
] = {
417 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
421 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
430 static struct rpc_filelist authfiles
[] = {
433 .i_fop
= &rpc_info_operations
,
434 .mode
= S_IFREG
| S_IRUSR
,
441 return simple_pin_fs("rpc_pipefs", &rpc_mount
, &rpc_mount_count
);
447 simple_release_fs(&rpc_mount
, &rpc_mount_count
);
451 rpc_lookup_parent(char *path
, struct nameidata
*nd
)
455 if (rpc_get_mount()) {
456 printk(KERN_WARNING
"%s: %s failed to mount "
457 "pseudofilesystem \n", __FILE__
, __FUNCTION__
);
460 nd
->mnt
= mntget(rpc_mount
);
461 nd
->dentry
= dget(rpc_mount
->mnt_root
);
462 nd
->last_type
= LAST_ROOT
;
463 nd
->flags
= LOOKUP_PARENT
;
466 if (path_walk(path
, nd
)) {
467 printk(KERN_WARNING
"%s: %s failed to find path %s\n",
468 __FILE__
, __FUNCTION__
, path
);
476 rpc_release_path(struct nameidata
*nd
)
482 static struct inode
*
483 rpc_get_inode(struct super_block
*sb
, int mode
)
485 struct inode
*inode
= new_inode(sb
);
488 inode
->i_mode
= mode
;
489 inode
->i_uid
= inode
->i_gid
= 0;
490 inode
->i_blksize
= PAGE_CACHE_SIZE
;
492 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
493 switch(mode
& S_IFMT
) {
495 inode
->i_fop
= &simple_dir_operations
;
496 inode
->i_op
= &simple_dir_inode_operations
;
505 * FIXME: This probably has races.
508 rpc_depopulate(struct dentry
*parent
)
510 struct inode
*dir
= parent
->d_inode
;
511 struct list_head
*pos
, *next
;
512 struct dentry
*dentry
, *dvec
[10];
515 mutex_lock(&dir
->i_mutex
);
517 spin_lock(&dcache_lock
);
518 list_for_each_safe(pos
, next
, &parent
->d_subdirs
) {
519 dentry
= list_entry(pos
, struct dentry
, d_u
.d_child
);
520 spin_lock(&dentry
->d_lock
);
521 if (!d_unhashed(dentry
)) {
524 spin_unlock(&dentry
->d_lock
);
526 if (n
== ARRAY_SIZE(dvec
))
529 spin_unlock(&dentry
->d_lock
);
531 spin_unlock(&dcache_lock
);
535 if (dentry
->d_inode
) {
536 rpc_close_pipes(dentry
->d_inode
);
537 simple_unlink(dir
, dentry
);
543 mutex_unlock(&dir
->i_mutex
);
547 rpc_populate(struct dentry
*parent
,
548 struct rpc_filelist
*files
,
551 struct inode
*inode
, *dir
= parent
->d_inode
;
552 void *private = RPC_I(dir
)->private;
553 struct dentry
*dentry
;
556 mutex_lock(&dir
->i_mutex
);
557 for (i
= start
; i
< eof
; i
++) {
558 dentry
= d_alloc_name(parent
, files
[i
].name
);
561 mode
= files
[i
].mode
;
562 inode
= rpc_get_inode(dir
->i_sb
, mode
);
569 inode
->i_fop
= files
[i
].i_fop
;
571 rpc_inode_setowner(inode
, private);
574 d_add(dentry
, inode
);
576 mutex_unlock(&dir
->i_mutex
);
579 mutex_unlock(&dir
->i_mutex
);
580 printk(KERN_WARNING
"%s: %s failed to populate directory %s\n",
581 __FILE__
, __FUNCTION__
, parent
->d_name
.name
);
586 __rpc_mkdir(struct inode
*dir
, struct dentry
*dentry
)
590 inode
= rpc_get_inode(dir
->i_sb
, S_IFDIR
| S_IRUSR
| S_IXUSR
);
593 inode
->i_ino
= iunique(dir
->i_sb
, 100);
594 d_instantiate(dentry
, inode
);
596 inode_dir_notify(dir
, DN_CREATE
);
600 printk(KERN_WARNING
"%s: %s failed to allocate inode for dentry %s\n",
601 __FILE__
, __FUNCTION__
, dentry
->d_name
.name
);
606 __rpc_rmdir(struct inode
*dir
, struct dentry
*dentry
)
610 shrink_dcache_parent(dentry
);
612 rpc_close_pipes(dentry
->d_inode
);
613 if ((error
= simple_rmdir(dir
, dentry
)) != 0)
616 inode_dir_notify(dir
, DN_DELETE
);
623 static struct dentry
*
624 rpc_lookup_negative(char *path
, struct nameidata
*nd
)
626 struct dentry
*dentry
;
630 if ((error
= rpc_lookup_parent(path
, nd
)) != 0)
631 return ERR_PTR(error
);
632 dir
= nd
->dentry
->d_inode
;
633 mutex_lock(&dir
->i_mutex
);
634 dentry
= lookup_one_len(nd
->last
.name
, nd
->dentry
, nd
->last
.len
);
637 if (dentry
->d_inode
) {
639 dentry
= ERR_PTR(-EEXIST
);
644 mutex_unlock(&dir
->i_mutex
);
645 rpc_release_path(nd
);
651 rpc_mkdir(char *path
, struct rpc_clnt
*rpc_client
)
654 struct dentry
*dentry
;
658 dentry
= rpc_lookup_negative(path
, &nd
);
661 dir
= nd
.dentry
->d_inode
;
662 if ((error
= __rpc_mkdir(dir
, dentry
)) != 0)
664 RPC_I(dentry
->d_inode
)->private = rpc_client
;
665 error
= rpc_populate(dentry
, authfiles
,
666 RPCAUTH_info
, RPCAUTH_EOF
);
670 mutex_unlock(&dir
->i_mutex
);
671 rpc_release_path(&nd
);
674 rpc_depopulate(dentry
);
675 __rpc_rmdir(dir
, dentry
);
678 printk(KERN_WARNING
"%s: %s() failed to create directory %s (errno = %d)\n",
679 __FILE__
, __FUNCTION__
, path
, error
);
680 dentry
= ERR_PTR(error
);
685 rpc_rmdir(char *path
)
688 struct dentry
*dentry
;
692 if ((error
= rpc_lookup_parent(path
, &nd
)) != 0)
694 dir
= nd
.dentry
->d_inode
;
695 mutex_lock(&dir
->i_mutex
);
696 dentry
= lookup_one_len(nd
.last
.name
, nd
.dentry
, nd
.last
.len
);
697 if (IS_ERR(dentry
)) {
698 error
= PTR_ERR(dentry
);
701 rpc_depopulate(dentry
);
702 error
= __rpc_rmdir(dir
, dentry
);
705 mutex_unlock(&dir
->i_mutex
);
706 rpc_release_path(&nd
);
711 rpc_mkpipe(char *path
, void *private, struct rpc_pipe_ops
*ops
, int flags
)
714 struct dentry
*dentry
;
715 struct inode
*dir
, *inode
;
716 struct rpc_inode
*rpci
;
718 dentry
= rpc_lookup_negative(path
, &nd
);
721 dir
= nd
.dentry
->d_inode
;
722 inode
= rpc_get_inode(dir
->i_sb
, S_IFSOCK
| S_IRUSR
| S_IWUSR
);
725 inode
->i_ino
= iunique(dir
->i_sb
, 100);
726 inode
->i_fop
= &rpc_pipe_fops
;
727 d_instantiate(dentry
, inode
);
729 rpci
->private = private;
732 inode_dir_notify(dir
, DN_CREATE
);
734 mutex_unlock(&dir
->i_mutex
);
735 rpc_release_path(&nd
);
739 dentry
= ERR_PTR(-ENOMEM
);
740 printk(KERN_WARNING
"%s: %s() failed to create pipe %s (errno = %d)\n",
741 __FILE__
, __FUNCTION__
, path
, -ENOMEM
);
746 rpc_unlink(char *path
)
749 struct dentry
*dentry
;
753 if ((error
= rpc_lookup_parent(path
, &nd
)) != 0)
755 dir
= nd
.dentry
->d_inode
;
756 mutex_lock(&dir
->i_mutex
);
757 dentry
= lookup_one_len(nd
.last
.name
, nd
.dentry
, nd
.last
.len
);
758 if (IS_ERR(dentry
)) {
759 error
= PTR_ERR(dentry
);
763 if (dentry
->d_inode
) {
764 rpc_close_pipes(dentry
->d_inode
);
765 error
= simple_unlink(dir
, dentry
);
768 inode_dir_notify(dir
, DN_DELETE
);
770 mutex_unlock(&dir
->i_mutex
);
771 rpc_release_path(&nd
);
776 * populate the filesystem
778 static struct super_operations s_ops
= {
779 .alloc_inode
= rpc_alloc_inode
,
780 .destroy_inode
= rpc_destroy_inode
,
781 .statfs
= simple_statfs
,
784 #define RPCAUTH_GSSMAGIC 0x67596969
787 rpc_fill_super(struct super_block
*sb
, void *data
, int silent
)
792 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
793 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
794 sb
->s_magic
= RPCAUTH_GSSMAGIC
;
798 inode
= rpc_get_inode(sb
, S_IFDIR
| 0755);
801 root
= d_alloc_root(inode
);
806 if (rpc_populate(root
, files
, RPCAUTH_Root
+ 1, RPCAUTH_RootEOF
))
816 static struct super_block
*
817 rpc_get_sb(struct file_system_type
*fs_type
,
818 int flags
, const char *dev_name
, void *data
)
820 return get_sb_single(fs_type
, flags
, data
, rpc_fill_super
);
823 static struct file_system_type rpc_pipe_fs_type
= {
824 .owner
= THIS_MODULE
,
825 .name
= "rpc_pipefs",
826 .get_sb
= rpc_get_sb
,
827 .kill_sb
= kill_litter_super
,
831 init_once(void * foo
, kmem_cache_t
* cachep
, unsigned long flags
)
833 struct rpc_inode
*rpci
= (struct rpc_inode
*) foo
;
835 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
836 SLAB_CTOR_CONSTRUCTOR
) {
837 inode_init_once(&rpci
->vfs_inode
);
838 rpci
->private = NULL
;
841 INIT_LIST_HEAD(&rpci
->in_upcall
);
842 INIT_LIST_HEAD(&rpci
->pipe
);
844 init_waitqueue_head(&rpci
->waitq
);
845 INIT_WORK(&rpci
->queue_timeout
, rpc_timeout_upcall_queue
, rpci
);
850 int register_rpc_pipefs(void)
852 rpc_inode_cachep
= kmem_cache_create("rpc_inode_cache",
853 sizeof(struct rpc_inode
),
854 0, SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
,
856 if (!rpc_inode_cachep
)
858 register_filesystem(&rpc_pipe_fs_type
);
862 void unregister_rpc_pipefs(void)
864 if (kmem_cache_destroy(rpc_inode_cachep
))
865 printk(KERN_WARNING
"RPC: unable to free inode cache\n");
866 unregister_filesystem(&rpc_pipe_fs_type
);