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
);
50 list_del_init(&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_init(&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_init(&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
= NULL
;
367 int ret
= single_open(file
, rpc_show_info
, NULL
);
370 struct seq_file
*m
= file
->private_data
;
372 spin_lock(&file
->f_path
.dentry
->d_lock
);
373 if (!d_unhashed(file
->f_path
.dentry
))
374 clnt
= RPC_I(inode
)->private;
375 if (clnt
!= NULL
&& atomic_inc_not_zero(&clnt
->cl_count
)) {
376 spin_unlock(&file
->f_path
.dentry
->d_lock
);
379 spin_unlock(&file
->f_path
.dentry
->d_lock
);
380 single_release(inode
, file
);
388 rpc_info_release(struct inode
*inode
, struct file
*file
)
390 struct seq_file
*m
= file
->private_data
;
391 struct rpc_clnt
*clnt
= (struct rpc_clnt
*)m
->private;
394 rpc_release_client(clnt
);
395 return single_release(inode
, file
);
398 static const struct file_operations rpc_info_operations
= {
399 .owner
= THIS_MODULE
,
400 .open
= rpc_info_open
,
403 .release
= rpc_info_release
,
408 * Description of fs contents.
410 struct rpc_filelist
{
412 const struct file_operations
*i_fop
;
416 struct vfsmount
*rpc_get_mount(void)
420 err
= simple_pin_fs(&rpc_pipe_fs_type
, &rpc_mount
, &rpc_mount_count
);
425 EXPORT_SYMBOL_GPL(rpc_get_mount
);
427 void rpc_put_mount(void)
429 simple_release_fs(&rpc_mount
, &rpc_mount_count
);
431 EXPORT_SYMBOL_GPL(rpc_put_mount
);
433 static int rpc_delete_dentry(struct dentry
*dentry
)
438 static const struct dentry_operations rpc_dentry_operations
= {
439 .d_delete
= rpc_delete_dentry
,
442 static struct inode
*
443 rpc_get_inode(struct super_block
*sb
, umode_t mode
)
445 struct inode
*inode
= new_inode(sb
);
448 inode
->i_mode
= mode
;
449 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
450 switch(mode
& S_IFMT
) {
452 inode
->i_fop
= &simple_dir_operations
;
453 inode
->i_op
= &simple_dir_inode_operations
;
461 static int __rpc_create_common(struct inode
*dir
, struct dentry
*dentry
,
463 const struct file_operations
*i_fop
,
468 BUG_ON(!d_unhashed(dentry
));
469 inode
= rpc_get_inode(dir
->i_sb
, mode
);
472 inode
->i_ino
= iunique(dir
->i_sb
, 100);
474 inode
->i_fop
= i_fop
;
476 rpc_inode_setowner(inode
, private);
477 d_add(dentry
, inode
);
480 printk(KERN_WARNING
"%s: %s failed to allocate inode for dentry %s\n",
481 __FILE__
, __func__
, dentry
->d_name
.name
);
486 static int __rpc_create(struct inode
*dir
, struct dentry
*dentry
,
488 const struct file_operations
*i_fop
,
493 err
= __rpc_create_common(dir
, dentry
, S_IFREG
| mode
, i_fop
, private);
496 fsnotify_create(dir
, dentry
);
500 static int __rpc_mkdir(struct inode
*dir
, struct dentry
*dentry
,
502 const struct file_operations
*i_fop
,
507 err
= __rpc_create_common(dir
, dentry
, S_IFDIR
| mode
, i_fop
, private);
511 fsnotify_mkdir(dir
, dentry
);
515 static int __rpc_mkpipe(struct inode
*dir
, struct dentry
*dentry
,
517 const struct file_operations
*i_fop
,
519 const struct rpc_pipe_ops
*ops
,
522 struct rpc_inode
*rpci
;
525 err
= __rpc_create_common(dir
, dentry
, S_IFIFO
| mode
, i_fop
, private);
528 rpci
= RPC_I(dentry
->d_inode
);
529 rpci
->nkern_readwriters
= 1;
530 rpci
->private = private;
533 fsnotify_create(dir
, dentry
);
537 static int __rpc_rmdir(struct inode
*dir
, struct dentry
*dentry
)
542 ret
= simple_rmdir(dir
, dentry
);
548 static int __rpc_unlink(struct inode
*dir
, struct dentry
*dentry
)
553 ret
= simple_unlink(dir
, dentry
);
559 static int __rpc_rmpipe(struct inode
*dir
, struct dentry
*dentry
)
561 struct inode
*inode
= dentry
->d_inode
;
562 struct rpc_inode
*rpci
= RPC_I(inode
);
564 rpci
->nkern_readwriters
--;
565 if (rpci
->nkern_readwriters
!= 0)
567 rpc_close_pipes(inode
);
568 return __rpc_unlink(dir
, dentry
);
571 static struct dentry
*__rpc_lookup_create(struct dentry
*parent
,
574 struct dentry
*dentry
;
576 dentry
= d_lookup(parent
, name
);
578 dentry
= d_alloc(parent
, name
);
580 dentry
= ERR_PTR(-ENOMEM
);
584 if (!dentry
->d_inode
)
585 dentry
->d_op
= &rpc_dentry_operations
;
590 static struct dentry
*__rpc_lookup_create_exclusive(struct dentry
*parent
,
593 struct dentry
*dentry
;
595 dentry
= __rpc_lookup_create(parent
, name
);
598 if (dentry
->d_inode
== NULL
)
601 return ERR_PTR(-EEXIST
);
605 * FIXME: This probably has races.
607 static void __rpc_depopulate(struct dentry
*parent
,
608 const struct rpc_filelist
*files
,
611 struct inode
*dir
= parent
->d_inode
;
612 struct dentry
*dentry
;
616 for (i
= start
; i
< eof
; i
++) {
617 name
.name
= files
[i
].name
;
618 name
.len
= strlen(files
[i
].name
);
619 name
.hash
= full_name_hash(name
.name
, name
.len
);
620 dentry
= d_lookup(parent
, &name
);
624 if (dentry
->d_inode
== NULL
)
626 switch (dentry
->d_inode
->i_mode
& S_IFMT
) {
630 __rpc_unlink(dir
, dentry
);
633 __rpc_rmdir(dir
, dentry
);
640 static void rpc_depopulate(struct dentry
*parent
,
641 const struct rpc_filelist
*files
,
644 struct inode
*dir
= parent
->d_inode
;
646 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_CHILD
);
647 __rpc_depopulate(parent
, files
, start
, eof
);
648 mutex_unlock(&dir
->i_mutex
);
651 static int rpc_populate(struct dentry
*parent
,
652 const struct rpc_filelist
*files
,
656 struct inode
*dir
= parent
->d_inode
;
657 struct dentry
*dentry
;
660 mutex_lock(&dir
->i_mutex
);
661 for (i
= start
; i
< eof
; i
++) {
664 q
.name
= files
[i
].name
;
665 q
.len
= strlen(files
[i
].name
);
666 q
.hash
= full_name_hash(q
.name
, q
.len
);
667 dentry
= __rpc_lookup_create_exclusive(parent
, &q
);
668 err
= PTR_ERR(dentry
);
671 switch (files
[i
].mode
& S_IFMT
) {
675 err
= __rpc_create(dir
, dentry
,
681 err
= __rpc_mkdir(dir
, dentry
,
689 mutex_unlock(&dir
->i_mutex
);
692 __rpc_depopulate(parent
, files
, start
, eof
);
693 mutex_unlock(&dir
->i_mutex
);
694 printk(KERN_WARNING
"%s: %s failed to populate directory %s\n",
695 __FILE__
, __func__
, parent
->d_name
.name
);
699 static struct dentry
*rpc_mkdir_populate(struct dentry
*parent
,
700 struct qstr
*name
, umode_t mode
, void *private,
701 int (*populate
)(struct dentry
*, void *), void *args_populate
)
703 struct dentry
*dentry
;
704 struct inode
*dir
= parent
->d_inode
;
707 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
708 dentry
= __rpc_lookup_create_exclusive(parent
, name
);
711 error
= __rpc_mkdir(dir
, dentry
, mode
, NULL
, private);
714 if (populate
!= NULL
) {
715 error
= populate(dentry
, args_populate
);
720 mutex_unlock(&dir
->i_mutex
);
723 __rpc_rmdir(dir
, dentry
);
725 dentry
= ERR_PTR(error
);
729 static int rpc_rmdir_depopulate(struct dentry
*dentry
,
730 void (*depopulate
)(struct dentry
*))
732 struct dentry
*parent
;
736 parent
= dget_parent(dentry
);
737 dir
= parent
->d_inode
;
738 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
739 if (depopulate
!= NULL
)
741 error
= __rpc_rmdir(dir
, dentry
);
742 mutex_unlock(&dir
->i_mutex
);
748 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
749 * @parent: dentry of directory to create new "pipe" in
750 * @name: name of pipe
751 * @private: private data to associate with the pipe, for the caller's use
752 * @ops: operations defining the behavior of the pipe: upcall, downcall,
753 * release_pipe, open_pipe, and destroy_msg.
754 * @flags: rpc_inode flags
756 * Data is made available for userspace to read by calls to
757 * rpc_queue_upcall(). The actual reads will result in calls to
758 * @ops->upcall, which will be called with the file pointer,
759 * message, and userspace buffer to copy to.
761 * Writes can come at any time, and do not necessarily have to be
762 * responses to upcalls. They will result in calls to @msg->downcall.
764 * The @private argument passed here will be available to all these methods
765 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
767 struct dentry
*rpc_mkpipe(struct dentry
*parent
, const char *name
,
768 void *private, const struct rpc_pipe_ops
*ops
,
771 struct dentry
*dentry
;
772 struct inode
*dir
= parent
->d_inode
;
773 umode_t umode
= S_IFIFO
| S_IRUSR
| S_IWUSR
;
777 if (ops
->upcall
== NULL
)
779 if (ops
->downcall
== NULL
)
783 q
.len
= strlen(name
);
784 q
.hash
= full_name_hash(q
.name
, q
.len
),
786 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
787 dentry
= __rpc_lookup_create(parent
, &q
);
790 if (dentry
->d_inode
) {
791 struct rpc_inode
*rpci
= RPC_I(dentry
->d_inode
);
792 if (rpci
->private != private ||
794 rpci
->flags
!= flags
) {
799 rpci
->nkern_readwriters
++;
803 err
= __rpc_mkpipe(dir
, dentry
, umode
, &rpc_pipe_fops
,
804 private, ops
, flags
);
808 mutex_unlock(&dir
->i_mutex
);
811 dentry
= ERR_PTR(err
);
812 printk(KERN_WARNING
"%s: %s() failed to create pipe %s/%s (errno = %d)\n",
813 __FILE__
, __func__
, parent
->d_name
.name
, name
,
817 EXPORT_SYMBOL_GPL(rpc_mkpipe
);
820 * rpc_unlink - remove a pipe
821 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
823 * After this call, lookups will no longer find the pipe, and any
824 * attempts to read or write using preexisting opens of the pipe will
828 rpc_unlink(struct dentry
*dentry
)
830 struct dentry
*parent
;
834 parent
= dget_parent(dentry
);
835 dir
= parent
->d_inode
;
836 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
837 error
= __rpc_rmpipe(dir
, dentry
);
838 mutex_unlock(&dir
->i_mutex
);
842 EXPORT_SYMBOL_GPL(rpc_unlink
);
849 static const struct rpc_filelist authfiles
[] = {
852 .i_fop
= &rpc_info_operations
,
853 .mode
= S_IFREG
| S_IRUSR
,
857 static int rpc_clntdir_populate(struct dentry
*dentry
, void *private)
859 return rpc_populate(dentry
,
860 authfiles
, RPCAUTH_info
, RPCAUTH_EOF
,
864 static void rpc_clntdir_depopulate(struct dentry
*dentry
)
866 rpc_depopulate(dentry
, authfiles
, RPCAUTH_info
, RPCAUTH_EOF
);
870 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
871 * @dentry: dentry from the rpc_pipefs root to the new directory
872 * @name: &struct qstr for the name
873 * @rpc_client: rpc client to associate with this directory
875 * This creates a directory at the given @path associated with
876 * @rpc_clnt, which will contain a file named "info" with some basic
877 * information about the client, together with any "pipes" that may
878 * later be created using rpc_mkpipe().
880 struct dentry
*rpc_create_client_dir(struct dentry
*dentry
,
882 struct rpc_clnt
*rpc_client
)
884 return rpc_mkdir_populate(dentry
, name
, S_IRUGO
| S_IXUGO
, NULL
,
885 rpc_clntdir_populate
, rpc_client
);
889 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
890 * @dentry: directory to remove
892 int rpc_remove_client_dir(struct dentry
*dentry
)
894 return rpc_rmdir_depopulate(dentry
, rpc_clntdir_depopulate
);
897 static const struct rpc_filelist cache_pipefs_files
[3] = {
900 .i_fop
= &cache_file_operations_pipefs
,
901 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
905 .i_fop
= &content_file_operations_pipefs
,
906 .mode
= S_IFREG
|S_IRUSR
,
910 .i_fop
= &cache_flush_operations_pipefs
,
911 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
915 static int rpc_cachedir_populate(struct dentry
*dentry
, void *private)
917 return rpc_populate(dentry
,
918 cache_pipefs_files
, 0, 3,
922 static void rpc_cachedir_depopulate(struct dentry
*dentry
)
924 rpc_depopulate(dentry
, cache_pipefs_files
, 0, 3);
927 struct dentry
*rpc_create_cache_dir(struct dentry
*parent
, struct qstr
*name
,
928 mode_t umode
, struct cache_detail
*cd
)
930 return rpc_mkdir_populate(parent
, name
, umode
, NULL
,
931 rpc_cachedir_populate
, cd
);
934 void rpc_remove_cache_dir(struct dentry
*dentry
)
936 rpc_rmdir_depopulate(dentry
, rpc_cachedir_depopulate
);
940 * populate the filesystem
942 static const struct super_operations s_ops
= {
943 .alloc_inode
= rpc_alloc_inode
,
944 .destroy_inode
= rpc_destroy_inode
,
945 .statfs
= simple_statfs
,
948 #define RPCAUTH_GSSMAGIC 0x67596969
951 * We have a single directory with 1 node in it.
964 static const struct rpc_filelist files
[] = {
967 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
971 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
975 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
977 [RPCAUTH_portmap
] = {
979 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
983 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
985 [RPCAUTH_nfsd4_cb
] = {
987 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
991 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
996 rpc_fill_super(struct super_block
*sb
, void *data
, int silent
)
1001 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
1002 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
1003 sb
->s_magic
= RPCAUTH_GSSMAGIC
;
1005 sb
->s_time_gran
= 1;
1007 inode
= rpc_get_inode(sb
, S_IFDIR
| 0755);
1010 sb
->s_root
= root
= d_alloc_root(inode
);
1015 if (rpc_populate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
, NULL
))
1021 rpc_get_sb(struct file_system_type
*fs_type
,
1022 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
1024 return get_sb_single(fs_type
, flags
, data
, rpc_fill_super
, mnt
);
1027 static struct file_system_type rpc_pipe_fs_type
= {
1028 .owner
= THIS_MODULE
,
1029 .name
= "rpc_pipefs",
1030 .get_sb
= rpc_get_sb
,
1031 .kill_sb
= kill_litter_super
,
1035 init_once(void *foo
)
1037 struct rpc_inode
*rpci
= (struct rpc_inode
*) foo
;
1039 inode_init_once(&rpci
->vfs_inode
);
1040 rpci
->private = NULL
;
1043 INIT_LIST_HEAD(&rpci
->in_upcall
);
1044 INIT_LIST_HEAD(&rpci
->in_downcall
);
1045 INIT_LIST_HEAD(&rpci
->pipe
);
1047 init_waitqueue_head(&rpci
->waitq
);
1048 INIT_DELAYED_WORK(&rpci
->queue_timeout
,
1049 rpc_timeout_upcall_queue
);
1053 int register_rpc_pipefs(void)
1057 rpc_inode_cachep
= kmem_cache_create("rpc_inode_cache",
1058 sizeof(struct rpc_inode
),
1059 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
1062 if (!rpc_inode_cachep
)
1064 err
= register_filesystem(&rpc_pipe_fs_type
);
1066 kmem_cache_destroy(rpc_inode_cachep
);
1073 void unregister_rpc_pipefs(void)
1075 kmem_cache_destroy(rpc_inode_cachep
);
1076 unregister_filesystem(&rpc_pipe_fs_type
);