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/fsnotify.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>
29 #include <linux/sunrpc/cache.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 struct kmem_cache
*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(struct work_struct
*work
)
61 struct rpc_inode
*rpci
=
62 container_of(work
, struct rpc_inode
, queue_timeout
.work
);
63 struct inode
*inode
= &rpci
->vfs_inode
;
64 void (*destroy_msg
)(struct rpc_pipe_msg
*);
66 spin_lock(&inode
->i_lock
);
67 if (rpci
->ops
== NULL
) {
68 spin_unlock(&inode
->i_lock
);
71 destroy_msg
= rpci
->ops
->destroy_msg
;
72 if (rpci
->nreaders
== 0) {
73 list_splice_init(&rpci
->pipe
, &free_list
);
76 spin_unlock(&inode
->i_lock
);
77 rpc_purge_list(rpci
, &free_list
, destroy_msg
, -ETIMEDOUT
);
81 * rpc_queue_upcall - queue an upcall message to userspace
82 * @inode: inode of upcall pipe on which to queue given message
83 * @msg: message to queue
85 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
86 * A userspace process may then later read the upcall by performing a
87 * read on an open file for this inode. It is up to the caller to
88 * initialize the fields of @msg (other than @msg->list) appropriately.
91 rpc_queue_upcall(struct inode
*inode
, struct rpc_pipe_msg
*msg
)
93 struct rpc_inode
*rpci
= RPC_I(inode
);
96 spin_lock(&inode
->i_lock
);
97 if (rpci
->ops
== NULL
)
100 list_add_tail(&msg
->list
, &rpci
->pipe
);
101 rpci
->pipelen
+= msg
->len
;
103 } else if (rpci
->flags
& RPC_PIPE_WAIT_FOR_OPEN
) {
104 if (list_empty(&rpci
->pipe
))
105 queue_delayed_work(rpciod_workqueue
,
106 &rpci
->queue_timeout
,
108 list_add_tail(&msg
->list
, &rpci
->pipe
);
109 rpci
->pipelen
+= msg
->len
;
113 spin_unlock(&inode
->i_lock
);
114 wake_up(&rpci
->waitq
);
117 EXPORT_SYMBOL_GPL(rpc_queue_upcall
);
120 rpc_inode_setowner(struct inode
*inode
, void *private)
122 RPC_I(inode
)->private = private;
126 rpc_close_pipes(struct inode
*inode
)
128 struct rpc_inode
*rpci
= RPC_I(inode
);
129 const struct rpc_pipe_ops
*ops
;
132 mutex_lock(&inode
->i_mutex
);
135 LIST_HEAD(free_list
);
136 spin_lock(&inode
->i_lock
);
137 need_release
= rpci
->nreaders
!= 0 || rpci
->nwriters
!= 0;
139 list_splice_init(&rpci
->in_upcall
, &free_list
);
140 list_splice_init(&rpci
->pipe
, &free_list
);
143 spin_unlock(&inode
->i_lock
);
144 rpc_purge_list(rpci
, &free_list
, ops
->destroy_msg
, -EPIPE
);
146 if (need_release
&& ops
->release_pipe
)
147 ops
->release_pipe(inode
);
148 cancel_delayed_work_sync(&rpci
->queue_timeout
);
150 rpc_inode_setowner(inode
, NULL
);
151 mutex_unlock(&inode
->i_mutex
);
154 static struct inode
*
155 rpc_alloc_inode(struct super_block
*sb
)
157 struct rpc_inode
*rpci
;
158 rpci
= (struct rpc_inode
*)kmem_cache_alloc(rpc_inode_cachep
, GFP_KERNEL
);
161 return &rpci
->vfs_inode
;
165 rpc_destroy_inode(struct inode
*inode
)
167 kmem_cache_free(rpc_inode_cachep
, RPC_I(inode
));
171 rpc_pipe_open(struct inode
*inode
, struct file
*filp
)
173 struct rpc_inode
*rpci
= RPC_I(inode
);
177 mutex_lock(&inode
->i_mutex
);
178 if (rpci
->ops
== NULL
)
180 first_open
= rpci
->nreaders
== 0 && rpci
->nwriters
== 0;
181 if (first_open
&& rpci
->ops
->open_pipe
) {
182 res
= rpci
->ops
->open_pipe(inode
);
186 if (filp
->f_mode
& FMODE_READ
)
188 if (filp
->f_mode
& FMODE_WRITE
)
192 mutex_unlock(&inode
->i_mutex
);
197 rpc_pipe_release(struct inode
*inode
, struct file
*filp
)
199 struct rpc_inode
*rpci
= RPC_I(inode
);
200 struct rpc_pipe_msg
*msg
;
203 mutex_lock(&inode
->i_mutex
);
204 if (rpci
->ops
== NULL
)
206 msg
= (struct rpc_pipe_msg
*)filp
->private_data
;
208 spin_lock(&inode
->i_lock
);
209 msg
->errno
= -EAGAIN
;
210 list_del(&msg
->list
);
211 spin_unlock(&inode
->i_lock
);
212 rpci
->ops
->destroy_msg(msg
);
214 if (filp
->f_mode
& FMODE_WRITE
)
216 if (filp
->f_mode
& FMODE_READ
) {
218 if (rpci
->nreaders
== 0) {
219 LIST_HEAD(free_list
);
220 spin_lock(&inode
->i_lock
);
221 list_splice_init(&rpci
->pipe
, &free_list
);
223 spin_unlock(&inode
->i_lock
);
224 rpc_purge_list(rpci
, &free_list
,
225 rpci
->ops
->destroy_msg
, -EAGAIN
);
228 last_close
= rpci
->nwriters
== 0 && rpci
->nreaders
== 0;
229 if (last_close
&& rpci
->ops
->release_pipe
)
230 rpci
->ops
->release_pipe(inode
);
232 mutex_unlock(&inode
->i_mutex
);
237 rpc_pipe_read(struct file
*filp
, char __user
*buf
, size_t len
, loff_t
*offset
)
239 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
240 struct rpc_inode
*rpci
= RPC_I(inode
);
241 struct rpc_pipe_msg
*msg
;
244 mutex_lock(&inode
->i_mutex
);
245 if (rpci
->ops
== NULL
) {
249 msg
= filp
->private_data
;
251 spin_lock(&inode
->i_lock
);
252 if (!list_empty(&rpci
->pipe
)) {
253 msg
= list_entry(rpci
->pipe
.next
,
256 list_move(&msg
->list
, &rpci
->in_upcall
);
257 rpci
->pipelen
-= msg
->len
;
258 filp
->private_data
= msg
;
261 spin_unlock(&inode
->i_lock
);
265 /* NOTE: it is up to the callback to update msg->copied */
266 res
= rpci
->ops
->upcall(filp
, msg
, buf
, len
);
267 if (res
< 0 || msg
->len
== msg
->copied
) {
268 filp
->private_data
= NULL
;
269 spin_lock(&inode
->i_lock
);
270 list_del(&msg
->list
);
271 spin_unlock(&inode
->i_lock
);
272 rpci
->ops
->destroy_msg(msg
);
275 mutex_unlock(&inode
->i_mutex
);
280 rpc_pipe_write(struct file
*filp
, const char __user
*buf
, size_t len
, loff_t
*offset
)
282 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
283 struct rpc_inode
*rpci
= RPC_I(inode
);
286 mutex_lock(&inode
->i_mutex
);
288 if (rpci
->ops
!= NULL
)
289 res
= rpci
->ops
->downcall(filp
, buf
, len
);
290 mutex_unlock(&inode
->i_mutex
);
295 rpc_pipe_poll(struct file
*filp
, struct poll_table_struct
*wait
)
297 struct rpc_inode
*rpci
;
298 unsigned int mask
= 0;
300 rpci
= RPC_I(filp
->f_path
.dentry
->d_inode
);
301 poll_wait(filp
, &rpci
->waitq
, wait
);
303 mask
= POLLOUT
| POLLWRNORM
;
304 if (rpci
->ops
== NULL
)
305 mask
|= POLLERR
| POLLHUP
;
306 if (filp
->private_data
|| !list_empty(&rpci
->pipe
))
307 mask
|= POLLIN
| POLLRDNORM
;
312 rpc_pipe_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
314 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
315 struct rpc_inode
*rpci
= RPC_I(inode
);
320 spin_lock(&inode
->i_lock
);
321 if (rpci
->ops
== NULL
) {
322 spin_unlock(&inode
->i_lock
);
326 if (filp
->private_data
) {
327 struct rpc_pipe_msg
*msg
;
328 msg
= (struct rpc_pipe_msg
*)filp
->private_data
;
329 len
+= msg
->len
- msg
->copied
;
331 spin_unlock(&inode
->i_lock
);
332 return put_user(len
, (int __user
*)arg
);
338 static const struct file_operations rpc_pipe_fops
= {
339 .owner
= THIS_MODULE
,
341 .read
= rpc_pipe_read
,
342 .write
= rpc_pipe_write
,
343 .poll
= rpc_pipe_poll
,
344 .unlocked_ioctl
= rpc_pipe_ioctl
,
345 .open
= rpc_pipe_open
,
346 .release
= rpc_pipe_release
,
350 rpc_show_info(struct seq_file
*m
, void *v
)
352 struct rpc_clnt
*clnt
= m
->private;
354 seq_printf(m
, "RPC server: %s\n", clnt
->cl_server
);
355 seq_printf(m
, "service: %s (%d) version %d\n", clnt
->cl_protname
,
356 clnt
->cl_prog
, clnt
->cl_vers
);
357 seq_printf(m
, "address: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_ADDR
));
358 seq_printf(m
, "protocol: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PROTO
));
359 seq_printf(m
, "port: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PORT
));
364 rpc_info_open(struct inode
*inode
, struct file
*file
)
366 struct rpc_clnt
*clnt
;
367 int ret
= single_open(file
, rpc_show_info
, NULL
);
370 struct seq_file
*m
= file
->private_data
;
371 mutex_lock(&inode
->i_mutex
);
372 clnt
= RPC_I(inode
)->private;
374 kref_get(&clnt
->cl_kref
);
377 single_release(inode
, file
);
380 mutex_unlock(&inode
->i_mutex
);
386 rpc_info_release(struct inode
*inode
, struct file
*file
)
388 struct seq_file
*m
= file
->private_data
;
389 struct rpc_clnt
*clnt
= (struct rpc_clnt
*)m
->private;
392 rpc_release_client(clnt
);
393 return single_release(inode
, file
);
396 static const struct file_operations rpc_info_operations
= {
397 .owner
= THIS_MODULE
,
398 .open
= rpc_info_open
,
401 .release
= rpc_info_release
,
406 * Description of fs contents.
408 struct rpc_filelist
{
410 const struct file_operations
*i_fop
;
414 struct vfsmount
*rpc_get_mount(void)
418 err
= simple_pin_fs(&rpc_pipe_fs_type
, &rpc_mount
, &rpc_mount_count
);
423 EXPORT_SYMBOL_GPL(rpc_get_mount
);
425 void rpc_put_mount(void)
427 simple_release_fs(&rpc_mount
, &rpc_mount_count
);
429 EXPORT_SYMBOL_GPL(rpc_put_mount
);
431 static int rpc_delete_dentry(struct dentry
*dentry
)
436 static const struct dentry_operations rpc_dentry_operations
= {
437 .d_delete
= rpc_delete_dentry
,
440 static struct inode
*
441 rpc_get_inode(struct super_block
*sb
, umode_t mode
)
443 struct inode
*inode
= new_inode(sb
);
446 inode
->i_mode
= mode
;
447 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
448 switch(mode
& S_IFMT
) {
450 inode
->i_fop
= &simple_dir_operations
;
451 inode
->i_op
= &simple_dir_inode_operations
;
459 static int __rpc_create_common(struct inode
*dir
, struct dentry
*dentry
,
461 const struct file_operations
*i_fop
,
466 BUG_ON(!d_unhashed(dentry
));
467 inode
= rpc_get_inode(dir
->i_sb
, mode
);
470 inode
->i_ino
= iunique(dir
->i_sb
, 100);
472 inode
->i_fop
= i_fop
;
474 rpc_inode_setowner(inode
, private);
475 d_add(dentry
, inode
);
478 printk(KERN_WARNING
"%s: %s failed to allocate inode for dentry %s\n",
479 __FILE__
, __func__
, dentry
->d_name
.name
);
484 static int __rpc_create(struct inode
*dir
, struct dentry
*dentry
,
486 const struct file_operations
*i_fop
,
491 err
= __rpc_create_common(dir
, dentry
, S_IFREG
| mode
, i_fop
, private);
494 fsnotify_create(dir
, dentry
);
498 static int __rpc_mkdir(struct inode
*dir
, struct dentry
*dentry
,
500 const struct file_operations
*i_fop
,
505 err
= __rpc_create_common(dir
, dentry
, S_IFDIR
| mode
, i_fop
, private);
509 fsnotify_mkdir(dir
, dentry
);
513 static int __rpc_mkpipe(struct inode
*dir
, struct dentry
*dentry
,
515 const struct file_operations
*i_fop
,
517 const struct rpc_pipe_ops
*ops
,
520 struct rpc_inode
*rpci
;
523 err
= __rpc_create_common(dir
, dentry
, S_IFIFO
| mode
, i_fop
, private);
526 rpci
= RPC_I(dentry
->d_inode
);
527 rpci
->nkern_readwriters
= 1;
528 rpci
->private = private;
531 fsnotify_create(dir
, dentry
);
535 static int __rpc_rmdir(struct inode
*dir
, struct dentry
*dentry
)
540 ret
= simple_rmdir(dir
, dentry
);
546 static int __rpc_unlink(struct inode
*dir
, struct dentry
*dentry
)
551 ret
= simple_unlink(dir
, dentry
);
557 static int __rpc_rmpipe(struct inode
*dir
, struct dentry
*dentry
)
559 struct inode
*inode
= dentry
->d_inode
;
560 struct rpc_inode
*rpci
= RPC_I(inode
);
562 rpci
->nkern_readwriters
--;
563 if (rpci
->nkern_readwriters
!= 0)
565 rpc_close_pipes(inode
);
566 return __rpc_unlink(dir
, dentry
);
569 static struct dentry
*__rpc_lookup_create(struct dentry
*parent
,
572 struct dentry
*dentry
;
574 dentry
= d_lookup(parent
, name
);
576 dentry
= d_alloc(parent
, name
);
578 dentry
= ERR_PTR(-ENOMEM
);
582 if (!dentry
->d_inode
)
583 dentry
->d_op
= &rpc_dentry_operations
;
588 static struct dentry
*__rpc_lookup_create_exclusive(struct dentry
*parent
,
591 struct dentry
*dentry
;
593 dentry
= __rpc_lookup_create(parent
, name
);
596 if (dentry
->d_inode
== NULL
)
599 return ERR_PTR(-EEXIST
);
603 * FIXME: This probably has races.
605 static void __rpc_depopulate(struct dentry
*parent
,
606 const struct rpc_filelist
*files
,
609 struct inode
*dir
= parent
->d_inode
;
610 struct dentry
*dentry
;
614 for (i
= start
; i
< eof
; i
++) {
615 name
.name
= files
[i
].name
;
616 name
.len
= strlen(files
[i
].name
);
617 name
.hash
= full_name_hash(name
.name
, name
.len
);
618 dentry
= d_lookup(parent
, &name
);
622 if (dentry
->d_inode
== NULL
)
624 switch (dentry
->d_inode
->i_mode
& S_IFMT
) {
628 __rpc_unlink(dir
, dentry
);
631 __rpc_rmdir(dir
, dentry
);
638 static void rpc_depopulate(struct dentry
*parent
,
639 const struct rpc_filelist
*files
,
642 struct inode
*dir
= parent
->d_inode
;
644 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_CHILD
);
645 __rpc_depopulate(parent
, files
, start
, eof
);
646 mutex_unlock(&dir
->i_mutex
);
649 static int rpc_populate(struct dentry
*parent
,
650 const struct rpc_filelist
*files
,
654 struct inode
*dir
= parent
->d_inode
;
655 struct dentry
*dentry
;
658 mutex_lock(&dir
->i_mutex
);
659 for (i
= start
; i
< eof
; i
++) {
662 q
.name
= files
[i
].name
;
663 q
.len
= strlen(files
[i
].name
);
664 q
.hash
= full_name_hash(q
.name
, q
.len
);
665 dentry
= __rpc_lookup_create_exclusive(parent
, &q
);
666 err
= PTR_ERR(dentry
);
669 switch (files
[i
].mode
& S_IFMT
) {
673 err
= __rpc_create(dir
, dentry
,
679 err
= __rpc_mkdir(dir
, dentry
,
687 mutex_unlock(&dir
->i_mutex
);
690 __rpc_depopulate(parent
, files
, start
, eof
);
691 mutex_unlock(&dir
->i_mutex
);
692 printk(KERN_WARNING
"%s: %s failed to populate directory %s\n",
693 __FILE__
, __func__
, parent
->d_name
.name
);
697 static struct dentry
*rpc_mkdir_populate(struct dentry
*parent
,
698 struct qstr
*name
, umode_t mode
, void *private,
699 int (*populate
)(struct dentry
*, void *), void *args_populate
)
701 struct dentry
*dentry
;
702 struct inode
*dir
= parent
->d_inode
;
705 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
706 dentry
= __rpc_lookup_create_exclusive(parent
, name
);
709 error
= __rpc_mkdir(dir
, dentry
, mode
, NULL
, private);
712 if (populate
!= NULL
) {
713 error
= populate(dentry
, args_populate
);
718 mutex_unlock(&dir
->i_mutex
);
721 __rpc_rmdir(dir
, dentry
);
723 dentry
= ERR_PTR(error
);
727 static int rpc_rmdir_depopulate(struct dentry
*dentry
,
728 void (*depopulate
)(struct dentry
*))
730 struct dentry
*parent
;
734 parent
= dget_parent(dentry
);
735 dir
= parent
->d_inode
;
736 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
737 if (depopulate
!= NULL
)
739 error
= __rpc_rmdir(dir
, dentry
);
740 mutex_unlock(&dir
->i_mutex
);
746 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
747 * @parent: dentry of directory to create new "pipe" in
748 * @name: name of pipe
749 * @private: private data to associate with the pipe, for the caller's use
750 * @ops: operations defining the behavior of the pipe: upcall, downcall,
751 * release_pipe, open_pipe, and destroy_msg.
752 * @flags: rpc_inode flags
754 * Data is made available for userspace to read by calls to
755 * rpc_queue_upcall(). The actual reads will result in calls to
756 * @ops->upcall, which will be called with the file pointer,
757 * message, and userspace buffer to copy to.
759 * Writes can come at any time, and do not necessarily have to be
760 * responses to upcalls. They will result in calls to @msg->downcall.
762 * The @private argument passed here will be available to all these methods
763 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
765 struct dentry
*rpc_mkpipe(struct dentry
*parent
, const char *name
,
766 void *private, const struct rpc_pipe_ops
*ops
,
769 struct dentry
*dentry
;
770 struct inode
*dir
= parent
->d_inode
;
771 umode_t umode
= S_IFIFO
| S_IRUSR
| S_IWUSR
;
775 if (ops
->upcall
== NULL
)
777 if (ops
->downcall
== NULL
)
781 q
.len
= strlen(name
);
782 q
.hash
= full_name_hash(q
.name
, q
.len
),
784 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
785 dentry
= __rpc_lookup_create(parent
, &q
);
788 if (dentry
->d_inode
) {
789 struct rpc_inode
*rpci
= RPC_I(dentry
->d_inode
);
790 if (rpci
->private != private ||
792 rpci
->flags
!= flags
) {
797 rpci
->nkern_readwriters
++;
801 err
= __rpc_mkpipe(dir
, dentry
, umode
, &rpc_pipe_fops
,
802 private, ops
, flags
);
806 mutex_unlock(&dir
->i_mutex
);
809 dentry
= ERR_PTR(err
);
810 printk(KERN_WARNING
"%s: %s() failed to create pipe %s/%s (errno = %d)\n",
811 __FILE__
, __func__
, parent
->d_name
.name
, name
,
815 EXPORT_SYMBOL_GPL(rpc_mkpipe
);
818 * rpc_unlink - remove a pipe
819 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
821 * After this call, lookups will no longer find the pipe, and any
822 * attempts to read or write using preexisting opens of the pipe will
826 rpc_unlink(struct dentry
*dentry
)
828 struct dentry
*parent
;
832 parent
= dget_parent(dentry
);
833 dir
= parent
->d_inode
;
834 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
835 error
= __rpc_rmpipe(dir
, dentry
);
836 mutex_unlock(&dir
->i_mutex
);
840 EXPORT_SYMBOL_GPL(rpc_unlink
);
847 static const struct rpc_filelist authfiles
[] = {
850 .i_fop
= &rpc_info_operations
,
851 .mode
= S_IFREG
| S_IRUSR
,
855 static int rpc_clntdir_populate(struct dentry
*dentry
, void *private)
857 return rpc_populate(dentry
,
858 authfiles
, RPCAUTH_info
, RPCAUTH_EOF
,
862 static void rpc_clntdir_depopulate(struct dentry
*dentry
)
864 rpc_depopulate(dentry
, authfiles
, RPCAUTH_info
, RPCAUTH_EOF
);
868 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
869 * @dentry: dentry from the rpc_pipefs root to the new directory
870 * @name: &struct qstr for the name
871 * @rpc_client: rpc client to associate with this directory
873 * This creates a directory at the given @path associated with
874 * @rpc_clnt, which will contain a file named "info" with some basic
875 * information about the client, together with any "pipes" that may
876 * later be created using rpc_mkpipe().
878 struct dentry
*rpc_create_client_dir(struct dentry
*dentry
,
880 struct rpc_clnt
*rpc_client
)
882 return rpc_mkdir_populate(dentry
, name
, S_IRUGO
| S_IXUGO
, NULL
,
883 rpc_clntdir_populate
, rpc_client
);
887 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
888 * @dentry: directory to remove
890 int rpc_remove_client_dir(struct dentry
*dentry
)
892 return rpc_rmdir_depopulate(dentry
, rpc_clntdir_depopulate
);
895 static const struct rpc_filelist cache_pipefs_files
[3] = {
898 .i_fop
= &cache_file_operations_pipefs
,
899 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
903 .i_fop
= &content_file_operations_pipefs
,
904 .mode
= S_IFREG
|S_IRUSR
,
908 .i_fop
= &cache_flush_operations_pipefs
,
909 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
913 static int rpc_cachedir_populate(struct dentry
*dentry
, void *private)
915 return rpc_populate(dentry
,
916 cache_pipefs_files
, 0, 3,
920 static void rpc_cachedir_depopulate(struct dentry
*dentry
)
922 rpc_depopulate(dentry
, cache_pipefs_files
, 0, 3);
925 struct dentry
*rpc_create_cache_dir(struct dentry
*parent
, struct qstr
*name
,
926 mode_t umode
, struct cache_detail
*cd
)
928 return rpc_mkdir_populate(parent
, name
, umode
, NULL
,
929 rpc_cachedir_populate
, cd
);
932 void rpc_remove_cache_dir(struct dentry
*dentry
)
934 rpc_rmdir_depopulate(dentry
, rpc_cachedir_depopulate
);
938 * populate the filesystem
940 static const struct super_operations s_ops
= {
941 .alloc_inode
= rpc_alloc_inode
,
942 .destroy_inode
= rpc_destroy_inode
,
943 .statfs
= simple_statfs
,
946 #define RPCAUTH_GSSMAGIC 0x67596969
949 * We have a single directory with 1 node in it.
962 static const struct rpc_filelist files
[] = {
965 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
969 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
973 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
975 [RPCAUTH_portmap
] = {
977 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
981 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
983 [RPCAUTH_nfsd4_cb
] = {
985 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
989 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
994 rpc_fill_super(struct super_block
*sb
, void *data
, int silent
)
999 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
1000 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
1001 sb
->s_magic
= RPCAUTH_GSSMAGIC
;
1003 sb
->s_time_gran
= 1;
1005 inode
= rpc_get_inode(sb
, S_IFDIR
| 0755);
1008 sb
->s_root
= root
= d_alloc_root(inode
);
1013 if (rpc_populate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
, NULL
))
1019 rpc_get_sb(struct file_system_type
*fs_type
,
1020 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
1022 return get_sb_single(fs_type
, flags
, data
, rpc_fill_super
, mnt
);
1025 static struct file_system_type rpc_pipe_fs_type
= {
1026 .owner
= THIS_MODULE
,
1027 .name
= "rpc_pipefs",
1028 .get_sb
= rpc_get_sb
,
1029 .kill_sb
= kill_litter_super
,
1033 init_once(void *foo
)
1035 struct rpc_inode
*rpci
= (struct rpc_inode
*) foo
;
1037 inode_init_once(&rpci
->vfs_inode
);
1038 rpci
->private = NULL
;
1041 INIT_LIST_HEAD(&rpci
->in_upcall
);
1042 INIT_LIST_HEAD(&rpci
->in_downcall
);
1043 INIT_LIST_HEAD(&rpci
->pipe
);
1045 init_waitqueue_head(&rpci
->waitq
);
1046 INIT_DELAYED_WORK(&rpci
->queue_timeout
,
1047 rpc_timeout_upcall_queue
);
1051 int register_rpc_pipefs(void)
1055 rpc_inode_cachep
= kmem_cache_create("rpc_inode_cache",
1056 sizeof(struct rpc_inode
),
1057 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
1060 if (!rpc_inode_cachep
)
1062 err
= register_filesystem(&rpc_pipe_fs_type
);
1064 kmem_cache_destroy(rpc_inode_cachep
);
1071 void unregister_rpc_pipefs(void)
1073 kmem_cache_destroy(rpc_inode_cachep
);
1074 unregister_filesystem(&rpc_pipe_fs_type
);