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/module.h>
12 #include <linux/slab.h>
13 #include <linux/string.h>
14 #include <linux/pagemap.h>
15 #include <linux/mount.h>
16 #include <linux/namei.h>
17 #include <linux/dnotify.h>
18 #include <linux/kernel.h>
20 #include <asm/ioctls.h>
22 #include <linux/poll.h>
23 #include <linux/wait.h>
24 #include <linux/seq_file.h>
26 #include <linux/sunrpc/clnt.h>
27 #include <linux/workqueue.h>
28 #include <linux/sunrpc/rpc_pipe_fs.h>
30 static struct vfsmount
*rpc_mount __read_mostly
;
31 static int rpc_mount_count
;
33 static struct file_system_type rpc_pipe_fs_type
;
36 static struct kmem_cache
*rpc_inode_cachep __read_mostly
;
38 #define RPC_UPCALL_TIMEOUT (30*HZ)
40 static void rpc_purge_list(struct rpc_inode
*rpci
, struct list_head
*head
,
41 void (*destroy_msg
)(struct rpc_pipe_msg
*), int err
)
43 struct rpc_pipe_msg
*msg
;
48 msg
= list_entry(head
->next
, struct rpc_pipe_msg
, list
);
52 } while (!list_empty(head
));
53 wake_up(&rpci
->waitq
);
57 rpc_timeout_upcall_queue(struct work_struct
*work
)
60 struct rpc_inode
*rpci
=
61 container_of(work
, struct rpc_inode
, queue_timeout
.work
);
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
, GFP_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_path
.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_path
.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_path
.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_path
.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 const 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: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_ADDR
));
332 seq_printf(m
, "protocol: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PROTO
));
337 rpc_info_open(struct inode
*inode
, struct file
*file
)
339 struct rpc_clnt
*clnt
;
340 int ret
= single_open(file
, rpc_show_info
, NULL
);
343 struct seq_file
*m
= file
->private_data
;
344 mutex_lock(&inode
->i_mutex
);
345 clnt
= RPC_I(inode
)->private;
347 kref_get(&clnt
->cl_kref
);
350 single_release(inode
, file
);
353 mutex_unlock(&inode
->i_mutex
);
359 rpc_info_release(struct inode
*inode
, struct file
*file
)
361 struct seq_file
*m
= file
->private_data
;
362 struct rpc_clnt
*clnt
= (struct rpc_clnt
*)m
->private;
365 rpc_release_client(clnt
);
366 return single_release(inode
, file
);
369 static const struct file_operations rpc_info_operations
= {
370 .owner
= THIS_MODULE
,
371 .open
= rpc_info_open
,
374 .release
= rpc_info_release
,
379 * We have a single directory with 1 node in it.
392 * Description of fs contents.
394 struct rpc_filelist
{
396 const struct file_operations
*i_fop
;
400 static struct rpc_filelist files
[] = {
403 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
407 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
411 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
413 [RPCAUTH_portmap
] = {
415 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
419 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
428 static struct rpc_filelist authfiles
[] = {
431 .i_fop
= &rpc_info_operations
,
432 .mode
= S_IFREG
| S_IRUSR
,
436 struct vfsmount
*rpc_get_mount(void)
440 err
= simple_pin_fs(&rpc_pipe_fs_type
, &rpc_mount
, &rpc_mount_count
);
446 void rpc_put_mount(void)
448 simple_release_fs(&rpc_mount
, &rpc_mount_count
);
451 static int rpc_delete_dentry(struct dentry
*dentry
)
456 static struct dentry_operations rpc_dentry_operations
= {
457 .d_delete
= rpc_delete_dentry
,
461 rpc_lookup_parent(char *path
, struct nameidata
*nd
)
463 struct vfsmount
*mnt
;
468 mnt
= rpc_get_mount();
470 printk(KERN_WARNING
"%s: %s failed to mount "
471 "pseudofilesystem \n", __FILE__
, __FUNCTION__
);
475 if (vfs_path_lookup(mnt
->mnt_root
, mnt
, path
, LOOKUP_PARENT
, nd
)) {
476 printk(KERN_WARNING
"%s: %s failed to find path %s\n",
477 __FILE__
, __FUNCTION__
, path
);
485 rpc_release_path(struct nameidata
*nd
)
491 static struct inode
*
492 rpc_get_inode(struct super_block
*sb
, int mode
)
494 struct inode
*inode
= new_inode(sb
);
497 inode
->i_mode
= mode
;
498 inode
->i_uid
= inode
->i_gid
= 0;
500 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
501 switch(mode
& S_IFMT
) {
503 inode
->i_fop
= &simple_dir_operations
;
504 inode
->i_op
= &simple_dir_inode_operations
;
513 * FIXME: This probably has races.
516 rpc_depopulate(struct dentry
*parent
, int start
, int eof
)
518 struct inode
*dir
= parent
->d_inode
;
519 struct list_head
*pos
, *next
;
520 struct dentry
*dentry
, *dvec
[10];
523 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_CHILD
);
525 spin_lock(&dcache_lock
);
526 list_for_each_safe(pos
, next
, &parent
->d_subdirs
) {
527 dentry
= list_entry(pos
, struct dentry
, d_u
.d_child
);
528 if (!dentry
->d_inode
||
529 dentry
->d_inode
->i_ino
< start
||
530 dentry
->d_inode
->i_ino
>= eof
)
532 spin_lock(&dentry
->d_lock
);
533 if (!d_unhashed(dentry
)) {
536 spin_unlock(&dentry
->d_lock
);
538 if (n
== ARRAY_SIZE(dvec
))
541 spin_unlock(&dentry
->d_lock
);
543 spin_unlock(&dcache_lock
);
547 if (S_ISREG(dentry
->d_inode
->i_mode
))
548 simple_unlink(dir
, dentry
);
549 else if (S_ISDIR(dentry
->d_inode
->i_mode
))
550 simple_rmdir(dir
, dentry
);
556 mutex_unlock(&dir
->i_mutex
);
560 rpc_populate(struct dentry
*parent
,
561 struct rpc_filelist
*files
,
564 struct inode
*inode
, *dir
= parent
->d_inode
;
565 void *private = RPC_I(dir
)->private;
566 struct dentry
*dentry
;
569 mutex_lock(&dir
->i_mutex
);
570 for (i
= start
; i
< eof
; i
++) {
571 dentry
= d_alloc_name(parent
, files
[i
].name
);
574 dentry
->d_op
= &rpc_dentry_operations
;
575 mode
= files
[i
].mode
;
576 inode
= rpc_get_inode(dir
->i_sb
, mode
);
583 inode
->i_fop
= files
[i
].i_fop
;
585 rpc_inode_setowner(inode
, private);
588 d_add(dentry
, inode
);
590 mutex_unlock(&dir
->i_mutex
);
593 mutex_unlock(&dir
->i_mutex
);
594 printk(KERN_WARNING
"%s: %s failed to populate directory %s\n",
595 __FILE__
, __FUNCTION__
, parent
->d_name
.name
);
600 __rpc_mkdir(struct inode
*dir
, struct dentry
*dentry
)
604 inode
= rpc_get_inode(dir
->i_sb
, S_IFDIR
| S_IRUGO
| S_IXUGO
);
607 inode
->i_ino
= iunique(dir
->i_sb
, 100);
608 d_instantiate(dentry
, inode
);
610 inode_dir_notify(dir
, DN_CREATE
);
613 printk(KERN_WARNING
"%s: %s failed to allocate inode for dentry %s\n",
614 __FILE__
, __FUNCTION__
, dentry
->d_name
.name
);
619 __rpc_rmdir(struct inode
*dir
, struct dentry
*dentry
)
622 error
= simple_rmdir(dir
, dentry
);
628 static struct dentry
*
629 rpc_lookup_create(struct dentry
*parent
, const char *name
, int len
, int exclusive
)
631 struct inode
*dir
= parent
->d_inode
;
632 struct dentry
*dentry
;
634 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
635 dentry
= lookup_one_len(name
, parent
, len
);
638 if (!dentry
->d_inode
)
639 dentry
->d_op
= &rpc_dentry_operations
;
640 else if (exclusive
) {
642 dentry
= ERR_PTR(-EEXIST
);
647 mutex_unlock(&dir
->i_mutex
);
651 static struct dentry
*
652 rpc_lookup_negative(char *path
, struct nameidata
*nd
)
654 struct dentry
*dentry
;
657 if ((error
= rpc_lookup_parent(path
, nd
)) != 0)
658 return ERR_PTR(error
);
659 dentry
= rpc_lookup_create(nd
->dentry
, nd
->last
.name
, nd
->last
.len
, 1);
661 rpc_release_path(nd
);
667 rpc_mkdir(char *path
, struct rpc_clnt
*rpc_client
)
670 struct dentry
*dentry
;
674 dentry
= rpc_lookup_negative(path
, &nd
);
677 dir
= nd
.dentry
->d_inode
;
678 if ((error
= __rpc_mkdir(dir
, dentry
)) != 0)
680 RPC_I(dentry
->d_inode
)->private = rpc_client
;
681 error
= rpc_populate(dentry
, authfiles
,
682 RPCAUTH_info
, RPCAUTH_EOF
);
687 mutex_unlock(&dir
->i_mutex
);
688 rpc_release_path(&nd
);
691 rpc_depopulate(dentry
, RPCAUTH_info
, RPCAUTH_EOF
);
692 __rpc_rmdir(dir
, dentry
);
695 printk(KERN_WARNING
"%s: %s() failed to create directory %s (errno = %d)\n",
696 __FILE__
, __FUNCTION__
, path
, error
);
697 dentry
= ERR_PTR(error
);
702 rpc_rmdir(struct dentry
*dentry
)
704 struct dentry
*parent
;
708 parent
= dget_parent(dentry
);
709 dir
= parent
->d_inode
;
710 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
711 rpc_depopulate(dentry
, RPCAUTH_info
, RPCAUTH_EOF
);
712 error
= __rpc_rmdir(dir
, dentry
);
714 mutex_unlock(&dir
->i_mutex
);
720 rpc_mkpipe(struct dentry
*parent
, const char *name
, void *private, struct rpc_pipe_ops
*ops
, int flags
)
722 struct dentry
*dentry
;
723 struct inode
*dir
, *inode
;
724 struct rpc_inode
*rpci
;
726 dentry
= rpc_lookup_create(parent
, name
, strlen(name
), 0);
729 dir
= parent
->d_inode
;
730 if (dentry
->d_inode
) {
731 rpci
= RPC_I(dentry
->d_inode
);
732 if (rpci
->private != private ||
734 rpci
->flags
!= flags
) {
736 dentry
= ERR_PTR(-EBUSY
);
738 rpci
->nkern_readwriters
++;
741 inode
= rpc_get_inode(dir
->i_sb
, S_IFIFO
| S_IRUSR
| S_IWUSR
);
744 inode
->i_ino
= iunique(dir
->i_sb
, 100);
745 inode
->i_fop
= &rpc_pipe_fops
;
746 d_instantiate(dentry
, inode
);
748 rpci
->private = private;
751 rpci
->nkern_readwriters
= 1;
752 inode_dir_notify(dir
, DN_CREATE
);
755 mutex_unlock(&dir
->i_mutex
);
759 dentry
= ERR_PTR(-ENOMEM
);
760 printk(KERN_WARNING
"%s: %s() failed to create pipe %s/%s (errno = %d)\n",
761 __FILE__
, __FUNCTION__
, parent
->d_name
.name
, name
,
767 rpc_unlink(struct dentry
*dentry
)
769 struct dentry
*parent
;
773 parent
= dget_parent(dentry
);
774 dir
= parent
->d_inode
;
775 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
776 if (--RPC_I(dentry
->d_inode
)->nkern_readwriters
== 0) {
777 rpc_close_pipes(dentry
->d_inode
);
778 error
= simple_unlink(dir
, dentry
);
783 mutex_unlock(&dir
->i_mutex
);
789 * populate the filesystem
791 static struct super_operations s_ops
= {
792 .alloc_inode
= rpc_alloc_inode
,
793 .destroy_inode
= rpc_destroy_inode
,
794 .statfs
= simple_statfs
,
797 #define RPCAUTH_GSSMAGIC 0x67596969
800 rpc_fill_super(struct super_block
*sb
, void *data
, int silent
)
805 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
806 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
807 sb
->s_magic
= RPCAUTH_GSSMAGIC
;
811 inode
= rpc_get_inode(sb
, S_IFDIR
| 0755);
814 root
= d_alloc_root(inode
);
819 if (rpc_populate(root
, files
, RPCAUTH_Root
+ 1, RPCAUTH_RootEOF
))
830 rpc_get_sb(struct file_system_type
*fs_type
,
831 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
833 return get_sb_single(fs_type
, flags
, data
, rpc_fill_super
, mnt
);
836 static struct file_system_type rpc_pipe_fs_type
= {
837 .owner
= THIS_MODULE
,
838 .name
= "rpc_pipefs",
839 .get_sb
= rpc_get_sb
,
840 .kill_sb
= kill_litter_super
,
844 init_once(void * foo
, struct kmem_cache
* cachep
, unsigned long flags
)
846 struct rpc_inode
*rpci
= (struct rpc_inode
*) foo
;
848 inode_init_once(&rpci
->vfs_inode
);
849 rpci
->private = NULL
;
852 INIT_LIST_HEAD(&rpci
->in_upcall
);
853 INIT_LIST_HEAD(&rpci
->in_downcall
);
854 INIT_LIST_HEAD(&rpci
->pipe
);
856 init_waitqueue_head(&rpci
->waitq
);
857 INIT_DELAYED_WORK(&rpci
->queue_timeout
,
858 rpc_timeout_upcall_queue
);
862 int register_rpc_pipefs(void)
866 rpc_inode_cachep
= kmem_cache_create("rpc_inode_cache",
867 sizeof(struct rpc_inode
),
868 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
871 if (!rpc_inode_cachep
)
873 err
= register_filesystem(&rpc_pipe_fs_type
);
875 kmem_cache_destroy(rpc_inode_cachep
);
882 void unregister_rpc_pipefs(void)
884 kmem_cache_destroy(rpc_inode_cachep
);
885 unregister_filesystem(&rpc_pipe_fs_type
);