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
);
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 inode
*ino
, struct file
*filp
,
313 unsigned int cmd
, unsigned long arg
)
315 struct rpc_inode
*rpci
= RPC_I(filp
->f_path
.dentry
->d_inode
);
320 if (rpci
->ops
== NULL
)
323 if (filp
->private_data
) {
324 struct rpc_pipe_msg
*msg
;
325 msg
= (struct rpc_pipe_msg
*)filp
->private_data
;
326 len
+= msg
->len
- msg
->copied
;
328 return put_user(len
, (int __user
*)arg
);
334 static const struct file_operations rpc_pipe_fops
= {
335 .owner
= THIS_MODULE
,
337 .read
= rpc_pipe_read
,
338 .write
= rpc_pipe_write
,
339 .poll
= rpc_pipe_poll
,
340 .ioctl
= rpc_pipe_ioctl
,
341 .open
= rpc_pipe_open
,
342 .release
= rpc_pipe_release
,
346 rpc_show_info(struct seq_file
*m
, void *v
)
348 struct rpc_clnt
*clnt
= m
->private;
350 seq_printf(m
, "RPC server: %s\n", clnt
->cl_server
);
351 seq_printf(m
, "service: %s (%d) version %d\n", clnt
->cl_protname
,
352 clnt
->cl_prog
, clnt
->cl_vers
);
353 seq_printf(m
, "address: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_ADDR
));
354 seq_printf(m
, "protocol: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PROTO
));
355 seq_printf(m
, "port: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PORT
));
360 rpc_info_open(struct inode
*inode
, struct file
*file
)
362 struct rpc_clnt
*clnt
;
363 int ret
= single_open(file
, rpc_show_info
, NULL
);
366 struct seq_file
*m
= file
->private_data
;
367 mutex_lock(&inode
->i_mutex
);
368 clnt
= RPC_I(inode
)->private;
370 kref_get(&clnt
->cl_kref
);
373 single_release(inode
, file
);
376 mutex_unlock(&inode
->i_mutex
);
382 rpc_info_release(struct inode
*inode
, struct file
*file
)
384 struct seq_file
*m
= file
->private_data
;
385 struct rpc_clnt
*clnt
= (struct rpc_clnt
*)m
->private;
388 rpc_release_client(clnt
);
389 return single_release(inode
, file
);
392 static const struct file_operations rpc_info_operations
= {
393 .owner
= THIS_MODULE
,
394 .open
= rpc_info_open
,
397 .release
= rpc_info_release
,
402 * Description of fs contents.
404 struct rpc_filelist
{
406 const struct file_operations
*i_fop
;
410 struct vfsmount
*rpc_get_mount(void)
414 err
= simple_pin_fs(&rpc_pipe_fs_type
, &rpc_mount
, &rpc_mount_count
);
420 void rpc_put_mount(void)
422 simple_release_fs(&rpc_mount
, &rpc_mount_count
);
425 static int rpc_delete_dentry(struct dentry
*dentry
)
430 static const struct dentry_operations rpc_dentry_operations
= {
431 .d_delete
= rpc_delete_dentry
,
434 static struct inode
*
435 rpc_get_inode(struct super_block
*sb
, umode_t mode
)
437 struct inode
*inode
= new_inode(sb
);
440 inode
->i_mode
= mode
;
441 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
442 switch(mode
& S_IFMT
) {
444 inode
->i_fop
= &simple_dir_operations
;
445 inode
->i_op
= &simple_dir_inode_operations
;
453 static int __rpc_create_common(struct inode
*dir
, struct dentry
*dentry
,
455 const struct file_operations
*i_fop
,
460 BUG_ON(!d_unhashed(dentry
));
461 inode
= rpc_get_inode(dir
->i_sb
, mode
);
464 inode
->i_ino
= iunique(dir
->i_sb
, 100);
466 inode
->i_fop
= i_fop
;
468 rpc_inode_setowner(inode
, private);
469 d_add(dentry
, inode
);
472 printk(KERN_WARNING
"%s: %s failed to allocate inode for dentry %s\n",
473 __FILE__
, __func__
, dentry
->d_name
.name
);
478 static int __rpc_create(struct inode
*dir
, struct dentry
*dentry
,
480 const struct file_operations
*i_fop
,
485 err
= __rpc_create_common(dir
, dentry
, S_IFREG
| mode
, i_fop
, private);
488 fsnotify_create(dir
, dentry
);
492 static int __rpc_mkdir(struct inode
*dir
, struct dentry
*dentry
,
494 const struct file_operations
*i_fop
,
499 err
= __rpc_create_common(dir
, dentry
, S_IFDIR
| mode
, i_fop
, private);
503 fsnotify_mkdir(dir
, dentry
);
507 static int __rpc_mkpipe(struct inode
*dir
, struct dentry
*dentry
,
509 const struct file_operations
*i_fop
,
511 const struct rpc_pipe_ops
*ops
,
514 struct rpc_inode
*rpci
;
517 err
= __rpc_create_common(dir
, dentry
, S_IFIFO
| mode
, i_fop
, private);
520 rpci
= RPC_I(dentry
->d_inode
);
521 rpci
->nkern_readwriters
= 1;
522 rpci
->private = private;
525 fsnotify_create(dir
, dentry
);
529 static int __rpc_rmdir(struct inode
*dir
, struct dentry
*dentry
)
534 ret
= simple_rmdir(dir
, dentry
);
540 static int __rpc_unlink(struct inode
*dir
, struct dentry
*dentry
)
545 ret
= simple_unlink(dir
, dentry
);
551 static int __rpc_rmpipe(struct inode
*dir
, struct dentry
*dentry
)
553 struct inode
*inode
= dentry
->d_inode
;
554 struct rpc_inode
*rpci
= RPC_I(inode
);
556 rpci
->nkern_readwriters
--;
557 if (rpci
->nkern_readwriters
!= 0)
559 rpc_close_pipes(inode
);
560 return __rpc_unlink(dir
, dentry
);
563 static struct dentry
*__rpc_lookup_create(struct dentry
*parent
,
566 struct dentry
*dentry
;
568 dentry
= d_lookup(parent
, name
);
570 dentry
= d_alloc(parent
, name
);
572 dentry
= ERR_PTR(-ENOMEM
);
576 if (!dentry
->d_inode
)
577 dentry
->d_op
= &rpc_dentry_operations
;
582 static struct dentry
*__rpc_lookup_create_exclusive(struct dentry
*parent
,
585 struct dentry
*dentry
;
587 dentry
= __rpc_lookup_create(parent
, name
);
588 if (dentry
->d_inode
== NULL
)
591 return ERR_PTR(-EEXIST
);
595 * FIXME: This probably has races.
597 static void __rpc_depopulate(struct dentry
*parent
,
598 const struct rpc_filelist
*files
,
601 struct inode
*dir
= parent
->d_inode
;
602 struct dentry
*dentry
;
606 for (i
= start
; i
< eof
; i
++) {
607 name
.name
= files
[i
].name
;
608 name
.len
= strlen(files
[i
].name
);
609 name
.hash
= full_name_hash(name
.name
, name
.len
);
610 dentry
= d_lookup(parent
, &name
);
614 if (dentry
->d_inode
== NULL
)
616 switch (dentry
->d_inode
->i_mode
& S_IFMT
) {
620 __rpc_unlink(dir
, dentry
);
623 __rpc_rmdir(dir
, dentry
);
630 static void rpc_depopulate(struct dentry
*parent
,
631 const struct rpc_filelist
*files
,
634 struct inode
*dir
= parent
->d_inode
;
636 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_CHILD
);
637 __rpc_depopulate(parent
, files
, start
, eof
);
638 mutex_unlock(&dir
->i_mutex
);
641 static int rpc_populate(struct dentry
*parent
,
642 const struct rpc_filelist
*files
,
646 struct inode
*dir
= parent
->d_inode
;
647 struct dentry
*dentry
;
650 mutex_lock(&dir
->i_mutex
);
651 for (i
= start
; i
< eof
; i
++) {
654 q
.name
= files
[i
].name
;
655 q
.len
= strlen(files
[i
].name
);
656 q
.hash
= full_name_hash(q
.name
, q
.len
);
657 dentry
= __rpc_lookup_create_exclusive(parent
, &q
);
658 err
= PTR_ERR(dentry
);
661 switch (files
[i
].mode
& S_IFMT
) {
665 err
= __rpc_create(dir
, dentry
,
671 err
= __rpc_mkdir(dir
, dentry
,
679 mutex_unlock(&dir
->i_mutex
);
682 __rpc_depopulate(parent
, files
, start
, eof
);
683 mutex_unlock(&dir
->i_mutex
);
684 printk(KERN_WARNING
"%s: %s failed to populate directory %s\n",
685 __FILE__
, __func__
, parent
->d_name
.name
);
689 static struct dentry
*rpc_mkdir_populate(struct dentry
*parent
,
690 struct qstr
*name
, umode_t mode
, void *private,
691 int (*populate
)(struct dentry
*, void *), void *args_populate
)
693 struct dentry
*dentry
;
694 struct inode
*dir
= parent
->d_inode
;
697 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
698 dentry
= __rpc_lookup_create_exclusive(parent
, name
);
701 error
= __rpc_mkdir(dir
, dentry
, mode
, NULL
, private);
704 if (populate
!= NULL
) {
705 error
= populate(dentry
, args_populate
);
710 mutex_unlock(&dir
->i_mutex
);
713 __rpc_rmdir(dir
, dentry
);
715 dentry
= ERR_PTR(error
);
719 static int rpc_rmdir_depopulate(struct dentry
*dentry
,
720 void (*depopulate
)(struct dentry
*))
722 struct dentry
*parent
;
726 parent
= dget_parent(dentry
);
727 dir
= parent
->d_inode
;
728 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
729 if (depopulate
!= NULL
)
731 error
= __rpc_rmdir(dir
, dentry
);
732 mutex_unlock(&dir
->i_mutex
);
738 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
739 * @parent: dentry of directory to create new "pipe" in
740 * @name: name of pipe
741 * @private: private data to associate with the pipe, for the caller's use
742 * @ops: operations defining the behavior of the pipe: upcall, downcall,
743 * release_pipe, open_pipe, and destroy_msg.
744 * @flags: rpc_inode flags
746 * Data is made available for userspace to read by calls to
747 * rpc_queue_upcall(). The actual reads will result in calls to
748 * @ops->upcall, which will be called with the file pointer,
749 * message, and userspace buffer to copy to.
751 * Writes can come at any time, and do not necessarily have to be
752 * responses to upcalls. They will result in calls to @msg->downcall.
754 * The @private argument passed here will be available to all these methods
755 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
757 struct dentry
*rpc_mkpipe(struct dentry
*parent
, const char *name
,
758 void *private, const struct rpc_pipe_ops
*ops
,
761 struct dentry
*dentry
;
762 struct inode
*dir
= parent
->d_inode
;
763 umode_t umode
= S_IFIFO
| S_IRUSR
| S_IWUSR
;
767 if (ops
->upcall
== NULL
)
769 if (ops
->downcall
== NULL
)
773 q
.len
= strlen(name
);
774 q
.hash
= full_name_hash(q
.name
, q
.len
),
776 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
777 dentry
= __rpc_lookup_create(parent
, &q
);
780 if (dentry
->d_inode
) {
781 struct rpc_inode
*rpci
= RPC_I(dentry
->d_inode
);
782 if (rpci
->private != private ||
784 rpci
->flags
!= flags
) {
789 rpci
->nkern_readwriters
++;
793 err
= __rpc_mkpipe(dir
, dentry
, umode
, &rpc_pipe_fops
,
794 private, ops
, flags
);
798 mutex_unlock(&dir
->i_mutex
);
801 dentry
= ERR_PTR(err
);
802 printk(KERN_WARNING
"%s: %s() failed to create pipe %s/%s (errno = %d)\n",
803 __FILE__
, __func__
, parent
->d_name
.name
, name
,
807 EXPORT_SYMBOL_GPL(rpc_mkpipe
);
810 * rpc_unlink - remove a pipe
811 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
813 * After this call, lookups will no longer find the pipe, and any
814 * attempts to read or write using preexisting opens of the pipe will
818 rpc_unlink(struct dentry
*dentry
)
820 struct dentry
*parent
;
824 parent
= dget_parent(dentry
);
825 dir
= parent
->d_inode
;
826 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
827 error
= __rpc_rmpipe(dir
, dentry
);
828 mutex_unlock(&dir
->i_mutex
);
832 EXPORT_SYMBOL_GPL(rpc_unlink
);
839 static const struct rpc_filelist authfiles
[] = {
842 .i_fop
= &rpc_info_operations
,
843 .mode
= S_IFREG
| S_IRUSR
,
847 static int rpc_clntdir_populate(struct dentry
*dentry
, void *private)
849 return rpc_populate(dentry
,
850 authfiles
, RPCAUTH_info
, RPCAUTH_EOF
,
854 static void rpc_clntdir_depopulate(struct dentry
*dentry
)
856 rpc_depopulate(dentry
, authfiles
, RPCAUTH_info
, RPCAUTH_EOF
);
860 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
861 * @path: path from the rpc_pipefs root to the new directory
862 * @rpc_client: rpc client to associate with this directory
864 * This creates a directory at the given @path associated with
865 * @rpc_clnt, which will contain a file named "info" with some basic
866 * information about the client, together with any "pipes" that may
867 * later be created using rpc_mkpipe().
869 struct dentry
*rpc_create_client_dir(struct dentry
*dentry
,
871 struct rpc_clnt
*rpc_client
)
873 return rpc_mkdir_populate(dentry
, name
, S_IRUGO
| S_IXUGO
, NULL
,
874 rpc_clntdir_populate
, rpc_client
);
878 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
879 * @dentry: directory to remove
881 int rpc_remove_client_dir(struct dentry
*dentry
)
883 return rpc_rmdir_depopulate(dentry
, rpc_clntdir_depopulate
);
886 static const struct rpc_filelist cache_pipefs_files
[3] = {
889 .i_fop
= &cache_file_operations_pipefs
,
890 .mode
= S_IFIFO
|S_IRUSR
|S_IWUSR
,
894 .i_fop
= &content_file_operations_pipefs
,
895 .mode
= S_IFREG
|S_IRUSR
,
899 .i_fop
= &cache_flush_operations_pipefs
,
900 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
904 static int rpc_cachedir_populate(struct dentry
*dentry
, void *private)
906 return rpc_populate(dentry
,
907 cache_pipefs_files
, 0, 3,
911 static void rpc_cachedir_depopulate(struct dentry
*dentry
)
913 rpc_depopulate(dentry
, cache_pipefs_files
, 0, 3);
916 struct dentry
*rpc_create_cache_dir(struct dentry
*parent
, struct qstr
*name
,
917 mode_t umode
, struct cache_detail
*cd
)
919 return rpc_mkdir_populate(parent
, name
, umode
, NULL
,
920 rpc_cachedir_populate
, cd
);
923 void rpc_remove_cache_dir(struct dentry
*dentry
)
925 rpc_rmdir_depopulate(dentry
, rpc_cachedir_depopulate
);
929 * populate the filesystem
931 static struct super_operations s_ops
= {
932 .alloc_inode
= rpc_alloc_inode
,
933 .destroy_inode
= rpc_destroy_inode
,
934 .statfs
= simple_statfs
,
937 #define RPCAUTH_GSSMAGIC 0x67596969
940 * We have a single directory with 1 node in it.
952 static const struct rpc_filelist files
[] = {
955 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
959 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
963 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
965 [RPCAUTH_portmap
] = {
967 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
971 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
973 [RPCAUTH_nfsd4_cb
] = {
975 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
980 rpc_fill_super(struct super_block
*sb
, void *data
, int silent
)
985 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
986 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
987 sb
->s_magic
= RPCAUTH_GSSMAGIC
;
991 inode
= rpc_get_inode(sb
, S_IFDIR
| 0755);
994 root
= d_alloc_root(inode
);
999 if (rpc_populate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
, NULL
))
1010 rpc_get_sb(struct file_system_type
*fs_type
,
1011 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
1013 return get_sb_single(fs_type
, flags
, data
, rpc_fill_super
, mnt
);
1016 static struct file_system_type rpc_pipe_fs_type
= {
1017 .owner
= THIS_MODULE
,
1018 .name
= "rpc_pipefs",
1019 .get_sb
= rpc_get_sb
,
1020 .kill_sb
= kill_litter_super
,
1024 init_once(void *foo
)
1026 struct rpc_inode
*rpci
= (struct rpc_inode
*) foo
;
1028 inode_init_once(&rpci
->vfs_inode
);
1029 rpci
->private = NULL
;
1032 INIT_LIST_HEAD(&rpci
->in_upcall
);
1033 INIT_LIST_HEAD(&rpci
->in_downcall
);
1034 INIT_LIST_HEAD(&rpci
->pipe
);
1036 init_waitqueue_head(&rpci
->waitq
);
1037 INIT_DELAYED_WORK(&rpci
->queue_timeout
,
1038 rpc_timeout_upcall_queue
);
1042 int register_rpc_pipefs(void)
1046 rpc_inode_cachep
= kmem_cache_create("rpc_inode_cache",
1047 sizeof(struct rpc_inode
),
1048 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
1051 if (!rpc_inode_cachep
)
1053 err
= register_filesystem(&rpc_pipe_fs_type
);
1055 kmem_cache_destroy(rpc_inode_cachep
);
1062 void unregister_rpc_pipefs(void)
1064 kmem_cache_destroy(rpc_inode_cachep
);
1065 unregister_filesystem(&rpc_pipe_fs_type
);