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>
19 #include <linux/rcupdate.h>
21 #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>
30 #include <linux/nsproxy.h>
31 #include <linux/notifier.h>
36 #define RPCDBG_FACILITY RPCDBG_DEBUG
38 #define NET_NAME(net) ((net == &init_net) ? " (init_net)" : "")
40 static struct file_system_type rpc_pipe_fs_type
;
43 static struct kmem_cache
*rpc_inode_cachep __read_mostly
;
45 #define RPC_UPCALL_TIMEOUT (30*HZ)
47 static BLOCKING_NOTIFIER_HEAD(rpc_pipefs_notifier_list
);
49 int rpc_pipefs_notifier_register(struct notifier_block
*nb
)
51 return blocking_notifier_chain_cond_register(&rpc_pipefs_notifier_list
, nb
);
53 EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_register
);
55 void rpc_pipefs_notifier_unregister(struct notifier_block
*nb
)
57 blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list
, nb
);
59 EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_unregister
);
61 static void rpc_purge_list(wait_queue_head_t
*waitq
, struct list_head
*head
,
62 void (*destroy_msg
)(struct rpc_pipe_msg
*), int err
)
64 struct rpc_pipe_msg
*msg
;
69 msg
= list_entry(head
->next
, struct rpc_pipe_msg
, list
);
70 list_del_init(&msg
->list
);
73 } while (!list_empty(head
));
80 rpc_timeout_upcall_queue(struct work_struct
*work
)
83 struct rpc_pipe
*pipe
=
84 container_of(work
, struct rpc_pipe
, queue_timeout
.work
);
85 void (*destroy_msg
)(struct rpc_pipe_msg
*);
86 struct dentry
*dentry
;
88 spin_lock(&pipe
->lock
);
89 destroy_msg
= pipe
->ops
->destroy_msg
;
90 if (pipe
->nreaders
== 0) {
91 list_splice_init(&pipe
->pipe
, &free_list
);
94 dentry
= dget(pipe
->dentry
);
95 spin_unlock(&pipe
->lock
);
96 rpc_purge_list(dentry
? &RPC_I(dentry
->d_inode
)->waitq
: NULL
,
97 &free_list
, destroy_msg
, -ETIMEDOUT
);
101 ssize_t
rpc_pipe_generic_upcall(struct file
*filp
, struct rpc_pipe_msg
*msg
,
102 char __user
*dst
, size_t buflen
)
104 char *data
= (char *)msg
->data
+ msg
->copied
;
105 size_t mlen
= min(msg
->len
- msg
->copied
, buflen
);
108 left
= copy_to_user(dst
, data
, mlen
);
110 msg
->errno
= -EFAULT
;
119 EXPORT_SYMBOL_GPL(rpc_pipe_generic_upcall
);
122 * rpc_queue_upcall - queue an upcall message to userspace
123 * @pipe: upcall pipe on which to queue given message
124 * @msg: message to queue
126 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
127 * A userspace process may then later read the upcall by performing a
128 * read on an open file for this inode. It is up to the caller to
129 * initialize the fields of @msg (other than @msg->list) appropriately.
132 rpc_queue_upcall(struct rpc_pipe
*pipe
, struct rpc_pipe_msg
*msg
)
135 struct dentry
*dentry
;
137 spin_lock(&pipe
->lock
);
138 if (pipe
->nreaders
) {
139 list_add_tail(&msg
->list
, &pipe
->pipe
);
140 pipe
->pipelen
+= msg
->len
;
142 } else if (pipe
->flags
& RPC_PIPE_WAIT_FOR_OPEN
) {
143 if (list_empty(&pipe
->pipe
))
144 queue_delayed_work(rpciod_workqueue
,
145 &pipe
->queue_timeout
,
147 list_add_tail(&msg
->list
, &pipe
->pipe
);
148 pipe
->pipelen
+= msg
->len
;
151 dentry
= dget(pipe
->dentry
);
152 spin_unlock(&pipe
->lock
);
154 wake_up(&RPC_I(dentry
->d_inode
)->waitq
);
159 EXPORT_SYMBOL_GPL(rpc_queue_upcall
);
162 rpc_inode_setowner(struct inode
*inode
, void *private)
164 RPC_I(inode
)->private = private;
168 rpc_close_pipes(struct inode
*inode
)
170 struct rpc_pipe
*pipe
= RPC_I(inode
)->pipe
;
172 LIST_HEAD(free_list
);
174 mutex_lock(&inode
->i_mutex
);
175 spin_lock(&pipe
->lock
);
176 need_release
= pipe
->nreaders
!= 0 || pipe
->nwriters
!= 0;
178 list_splice_init(&pipe
->in_upcall
, &free_list
);
179 list_splice_init(&pipe
->pipe
, &free_list
);
182 spin_unlock(&pipe
->lock
);
183 rpc_purge_list(&RPC_I(inode
)->waitq
, &free_list
, pipe
->ops
->destroy_msg
, -EPIPE
);
185 if (need_release
&& pipe
->ops
->release_pipe
)
186 pipe
->ops
->release_pipe(inode
);
187 cancel_delayed_work_sync(&pipe
->queue_timeout
);
188 rpc_inode_setowner(inode
, NULL
);
189 RPC_I(inode
)->pipe
= NULL
;
190 mutex_unlock(&inode
->i_mutex
);
193 static struct inode
*
194 rpc_alloc_inode(struct super_block
*sb
)
196 struct rpc_inode
*rpci
;
197 rpci
= (struct rpc_inode
*)kmem_cache_alloc(rpc_inode_cachep
, GFP_KERNEL
);
200 return &rpci
->vfs_inode
;
204 rpc_i_callback(struct rcu_head
*head
)
206 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
207 kmem_cache_free(rpc_inode_cachep
, RPC_I(inode
));
211 rpc_destroy_inode(struct inode
*inode
)
213 call_rcu(&inode
->i_rcu
, rpc_i_callback
);
217 rpc_pipe_open(struct inode
*inode
, struct file
*filp
)
219 struct net
*net
= inode
->i_sb
->s_fs_info
;
220 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
221 struct rpc_pipe
*pipe
;
225 mutex_lock(&inode
->i_mutex
);
226 sn
->gssd_running
= 1;
227 pipe
= RPC_I(inode
)->pipe
;
230 first_open
= pipe
->nreaders
== 0 && pipe
->nwriters
== 0;
231 if (first_open
&& pipe
->ops
->open_pipe
) {
232 res
= pipe
->ops
->open_pipe(inode
);
236 if (filp
->f_mode
& FMODE_READ
)
238 if (filp
->f_mode
& FMODE_WRITE
)
242 mutex_unlock(&inode
->i_mutex
);
247 rpc_pipe_release(struct inode
*inode
, struct file
*filp
)
249 struct rpc_pipe
*pipe
;
250 struct rpc_pipe_msg
*msg
;
253 mutex_lock(&inode
->i_mutex
);
254 pipe
= RPC_I(inode
)->pipe
;
257 msg
= filp
->private_data
;
259 spin_lock(&pipe
->lock
);
260 msg
->errno
= -EAGAIN
;
261 list_del_init(&msg
->list
);
262 spin_unlock(&pipe
->lock
);
263 pipe
->ops
->destroy_msg(msg
);
265 if (filp
->f_mode
& FMODE_WRITE
)
267 if (filp
->f_mode
& FMODE_READ
) {
269 if (pipe
->nreaders
== 0) {
270 LIST_HEAD(free_list
);
271 spin_lock(&pipe
->lock
);
272 list_splice_init(&pipe
->pipe
, &free_list
);
274 spin_unlock(&pipe
->lock
);
275 rpc_purge_list(&RPC_I(inode
)->waitq
, &free_list
,
276 pipe
->ops
->destroy_msg
, -EAGAIN
);
279 last_close
= pipe
->nwriters
== 0 && pipe
->nreaders
== 0;
280 if (last_close
&& pipe
->ops
->release_pipe
)
281 pipe
->ops
->release_pipe(inode
);
283 mutex_unlock(&inode
->i_mutex
);
288 rpc_pipe_read(struct file
*filp
, char __user
*buf
, size_t len
, loff_t
*offset
)
290 struct inode
*inode
= file_inode(filp
);
291 struct rpc_pipe
*pipe
;
292 struct rpc_pipe_msg
*msg
;
295 mutex_lock(&inode
->i_mutex
);
296 pipe
= RPC_I(inode
)->pipe
;
301 msg
= filp
->private_data
;
303 spin_lock(&pipe
->lock
);
304 if (!list_empty(&pipe
->pipe
)) {
305 msg
= list_entry(pipe
->pipe
.next
,
308 list_move(&msg
->list
, &pipe
->in_upcall
);
309 pipe
->pipelen
-= msg
->len
;
310 filp
->private_data
= msg
;
313 spin_unlock(&pipe
->lock
);
317 /* NOTE: it is up to the callback to update msg->copied */
318 res
= pipe
->ops
->upcall(filp
, msg
, buf
, len
);
319 if (res
< 0 || msg
->len
== msg
->copied
) {
320 filp
->private_data
= NULL
;
321 spin_lock(&pipe
->lock
);
322 list_del_init(&msg
->list
);
323 spin_unlock(&pipe
->lock
);
324 pipe
->ops
->destroy_msg(msg
);
327 mutex_unlock(&inode
->i_mutex
);
332 rpc_pipe_write(struct file
*filp
, const char __user
*buf
, size_t len
, loff_t
*offset
)
334 struct inode
*inode
= file_inode(filp
);
337 mutex_lock(&inode
->i_mutex
);
339 if (RPC_I(inode
)->pipe
!= NULL
)
340 res
= RPC_I(inode
)->pipe
->ops
->downcall(filp
, buf
, len
);
341 mutex_unlock(&inode
->i_mutex
);
346 rpc_pipe_poll(struct file
*filp
, struct poll_table_struct
*wait
)
348 struct inode
*inode
= file_inode(filp
);
349 struct rpc_inode
*rpci
= RPC_I(inode
);
350 unsigned int mask
= POLLOUT
| POLLWRNORM
;
352 poll_wait(filp
, &rpci
->waitq
, wait
);
354 mutex_lock(&inode
->i_mutex
);
355 if (rpci
->pipe
== NULL
)
356 mask
|= POLLERR
| POLLHUP
;
357 else if (filp
->private_data
|| !list_empty(&rpci
->pipe
->pipe
))
358 mask
|= POLLIN
| POLLRDNORM
;
359 mutex_unlock(&inode
->i_mutex
);
364 rpc_pipe_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
366 struct inode
*inode
= file_inode(filp
);
367 struct rpc_pipe
*pipe
;
372 mutex_lock(&inode
->i_mutex
);
373 pipe
= RPC_I(inode
)->pipe
;
375 mutex_unlock(&inode
->i_mutex
);
378 spin_lock(&pipe
->lock
);
380 if (filp
->private_data
) {
381 struct rpc_pipe_msg
*msg
;
382 msg
= filp
->private_data
;
383 len
+= msg
->len
- msg
->copied
;
385 spin_unlock(&pipe
->lock
);
386 mutex_unlock(&inode
->i_mutex
);
387 return put_user(len
, (int __user
*)arg
);
393 static const struct file_operations rpc_pipe_fops
= {
394 .owner
= THIS_MODULE
,
396 .read
= rpc_pipe_read
,
397 .write
= rpc_pipe_write
,
398 .poll
= rpc_pipe_poll
,
399 .unlocked_ioctl
= rpc_pipe_ioctl
,
400 .open
= rpc_pipe_open
,
401 .release
= rpc_pipe_release
,
405 rpc_show_info(struct seq_file
*m
, void *v
)
407 struct rpc_clnt
*clnt
= m
->private;
410 seq_printf(m
, "RPC server: %s\n",
411 rcu_dereference(clnt
->cl_xprt
)->servername
);
412 seq_printf(m
, "service: %s (%d) version %d\n", clnt
->cl_program
->name
,
413 clnt
->cl_prog
, clnt
->cl_vers
);
414 seq_printf(m
, "address: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_ADDR
));
415 seq_printf(m
, "protocol: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PROTO
));
416 seq_printf(m
, "port: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PORT
));
422 rpc_info_open(struct inode
*inode
, struct file
*file
)
424 struct rpc_clnt
*clnt
= NULL
;
425 int ret
= single_open(file
, rpc_show_info
, NULL
);
428 struct seq_file
*m
= file
->private_data
;
430 spin_lock(&file
->f_path
.dentry
->d_lock
);
431 if (!d_unhashed(file
->f_path
.dentry
))
432 clnt
= RPC_I(inode
)->private;
433 if (clnt
!= NULL
&& atomic_inc_not_zero(&clnt
->cl_count
)) {
434 spin_unlock(&file
->f_path
.dentry
->d_lock
);
437 spin_unlock(&file
->f_path
.dentry
->d_lock
);
438 single_release(inode
, file
);
446 rpc_info_release(struct inode
*inode
, struct file
*file
)
448 struct seq_file
*m
= file
->private_data
;
449 struct rpc_clnt
*clnt
= (struct rpc_clnt
*)m
->private;
452 rpc_release_client(clnt
);
453 return single_release(inode
, file
);
456 static const struct file_operations rpc_info_operations
= {
457 .owner
= THIS_MODULE
,
458 .open
= rpc_info_open
,
461 .release
= rpc_info_release
,
466 * Description of fs contents.
468 struct rpc_filelist
{
470 const struct file_operations
*i_fop
;
474 static struct inode
*
475 rpc_get_inode(struct super_block
*sb
, umode_t mode
)
477 struct inode
*inode
= new_inode(sb
);
480 inode
->i_ino
= get_next_ino();
481 inode
->i_mode
= mode
;
482 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
483 switch (mode
& S_IFMT
) {
485 inode
->i_fop
= &simple_dir_operations
;
486 inode
->i_op
= &simple_dir_inode_operations
;
494 static int __rpc_create_common(struct inode
*dir
, struct dentry
*dentry
,
496 const struct file_operations
*i_fop
,
502 inode
= rpc_get_inode(dir
->i_sb
, mode
);
505 inode
->i_ino
= iunique(dir
->i_sb
, 100);
507 inode
->i_fop
= i_fop
;
509 rpc_inode_setowner(inode
, private);
510 d_add(dentry
, inode
);
513 printk(KERN_WARNING
"%s: %s failed to allocate inode for dentry %pd\n",
514 __FILE__
, __func__
, dentry
);
519 static int __rpc_create(struct inode
*dir
, struct dentry
*dentry
,
521 const struct file_operations
*i_fop
,
526 err
= __rpc_create_common(dir
, dentry
, S_IFREG
| mode
, i_fop
, private);
529 fsnotify_create(dir
, dentry
);
533 static int __rpc_mkdir(struct inode
*dir
, struct dentry
*dentry
,
535 const struct file_operations
*i_fop
,
540 err
= __rpc_create_common(dir
, dentry
, S_IFDIR
| mode
, i_fop
, private);
544 fsnotify_mkdir(dir
, dentry
);
549 init_pipe(struct rpc_pipe
*pipe
)
553 INIT_LIST_HEAD(&pipe
->in_upcall
);
554 INIT_LIST_HEAD(&pipe
->in_downcall
);
555 INIT_LIST_HEAD(&pipe
->pipe
);
557 INIT_DELAYED_WORK(&pipe
->queue_timeout
,
558 rpc_timeout_upcall_queue
);
560 spin_lock_init(&pipe
->lock
);
564 void rpc_destroy_pipe_data(struct rpc_pipe
*pipe
)
568 EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data
);
570 struct rpc_pipe
*rpc_mkpipe_data(const struct rpc_pipe_ops
*ops
, int flags
)
572 struct rpc_pipe
*pipe
;
574 pipe
= kzalloc(sizeof(struct rpc_pipe
), GFP_KERNEL
);
576 return ERR_PTR(-ENOMEM
);
582 EXPORT_SYMBOL_GPL(rpc_mkpipe_data
);
584 static int __rpc_mkpipe_dentry(struct inode
*dir
, struct dentry
*dentry
,
586 const struct file_operations
*i_fop
,
588 struct rpc_pipe
*pipe
)
590 struct rpc_inode
*rpci
;
593 err
= __rpc_create_common(dir
, dentry
, S_IFIFO
| mode
, i_fop
, private);
596 rpci
= RPC_I(dentry
->d_inode
);
597 rpci
->private = private;
599 fsnotify_create(dir
, dentry
);
603 static int __rpc_rmdir(struct inode
*dir
, struct dentry
*dentry
)
608 ret
= simple_rmdir(dir
, dentry
);
614 int rpc_rmdir(struct dentry
*dentry
)
616 struct dentry
*parent
;
620 parent
= dget_parent(dentry
);
621 dir
= parent
->d_inode
;
622 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
623 error
= __rpc_rmdir(dir
, dentry
);
624 mutex_unlock(&dir
->i_mutex
);
628 EXPORT_SYMBOL_GPL(rpc_rmdir
);
630 static int __rpc_unlink(struct inode
*dir
, struct dentry
*dentry
)
635 ret
= simple_unlink(dir
, dentry
);
641 static int __rpc_rmpipe(struct inode
*dir
, struct dentry
*dentry
)
643 struct inode
*inode
= dentry
->d_inode
;
645 rpc_close_pipes(inode
);
646 return __rpc_unlink(dir
, dentry
);
649 static struct dentry
*__rpc_lookup_create_exclusive(struct dentry
*parent
,
652 struct qstr q
= QSTR_INIT(name
, strlen(name
));
653 struct dentry
*dentry
= d_hash_and_lookup(parent
, &q
);
655 dentry
= d_alloc(parent
, &q
);
657 return ERR_PTR(-ENOMEM
);
659 if (dentry
->d_inode
== NULL
)
662 return ERR_PTR(-EEXIST
);
666 * FIXME: This probably has races.
668 static void __rpc_depopulate(struct dentry
*parent
,
669 const struct rpc_filelist
*files
,
672 struct inode
*dir
= parent
->d_inode
;
673 struct dentry
*dentry
;
677 for (i
= start
; i
< eof
; i
++) {
678 name
.name
= files
[i
].name
;
679 name
.len
= strlen(files
[i
].name
);
680 dentry
= d_hash_and_lookup(parent
, &name
);
684 if (dentry
->d_inode
== NULL
)
686 switch (dentry
->d_inode
->i_mode
& S_IFMT
) {
690 __rpc_unlink(dir
, dentry
);
693 __rpc_rmdir(dir
, dentry
);
700 static void rpc_depopulate(struct dentry
*parent
,
701 const struct rpc_filelist
*files
,
704 struct inode
*dir
= parent
->d_inode
;
706 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_CHILD
);
707 __rpc_depopulate(parent
, files
, start
, eof
);
708 mutex_unlock(&dir
->i_mutex
);
711 static int rpc_populate(struct dentry
*parent
,
712 const struct rpc_filelist
*files
,
716 struct inode
*dir
= parent
->d_inode
;
717 struct dentry
*dentry
;
720 mutex_lock(&dir
->i_mutex
);
721 for (i
= start
; i
< eof
; i
++) {
722 dentry
= __rpc_lookup_create_exclusive(parent
, files
[i
].name
);
723 err
= PTR_ERR(dentry
);
726 switch (files
[i
].mode
& S_IFMT
) {
730 err
= __rpc_create(dir
, dentry
,
736 err
= __rpc_mkdir(dir
, dentry
,
744 mutex_unlock(&dir
->i_mutex
);
747 __rpc_depopulate(parent
, files
, start
, eof
);
748 mutex_unlock(&dir
->i_mutex
);
749 printk(KERN_WARNING
"%s: %s failed to populate directory %pd\n",
750 __FILE__
, __func__
, parent
);
754 static struct dentry
*rpc_mkdir_populate(struct dentry
*parent
,
755 const char *name
, umode_t mode
, void *private,
756 int (*populate
)(struct dentry
*, void *), void *args_populate
)
758 struct dentry
*dentry
;
759 struct inode
*dir
= parent
->d_inode
;
762 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
763 dentry
= __rpc_lookup_create_exclusive(parent
, name
);
766 error
= __rpc_mkdir(dir
, dentry
, mode
, NULL
, private);
769 if (populate
!= NULL
) {
770 error
= populate(dentry
, args_populate
);
775 mutex_unlock(&dir
->i_mutex
);
778 __rpc_rmdir(dir
, dentry
);
780 dentry
= ERR_PTR(error
);
784 static int rpc_rmdir_depopulate(struct dentry
*dentry
,
785 void (*depopulate
)(struct dentry
*))
787 struct dentry
*parent
;
791 parent
= dget_parent(dentry
);
792 dir
= parent
->d_inode
;
793 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
794 if (depopulate
!= NULL
)
796 error
= __rpc_rmdir(dir
, dentry
);
797 mutex_unlock(&dir
->i_mutex
);
803 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
804 * @parent: dentry of directory to create new "pipe" in
805 * @name: name of pipe
806 * @private: private data to associate with the pipe, for the caller's use
807 * @pipe: &rpc_pipe containing input parameters
809 * Data is made available for userspace to read by calls to
810 * rpc_queue_upcall(). The actual reads will result in calls to
811 * @ops->upcall, which will be called with the file pointer,
812 * message, and userspace buffer to copy to.
814 * Writes can come at any time, and do not necessarily have to be
815 * responses to upcalls. They will result in calls to @msg->downcall.
817 * The @private argument passed here will be available to all these methods
818 * from the file pointer, via RPC_I(file_inode(file))->private.
820 struct dentry
*rpc_mkpipe_dentry(struct dentry
*parent
, const char *name
,
821 void *private, struct rpc_pipe
*pipe
)
823 struct dentry
*dentry
;
824 struct inode
*dir
= parent
->d_inode
;
825 umode_t umode
= S_IFIFO
| S_IRUSR
| S_IWUSR
;
828 if (pipe
->ops
->upcall
== NULL
)
830 if (pipe
->ops
->downcall
== NULL
)
833 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
834 dentry
= __rpc_lookup_create_exclusive(parent
, name
);
837 err
= __rpc_mkpipe_dentry(dir
, dentry
, umode
, &rpc_pipe_fops
,
842 mutex_unlock(&dir
->i_mutex
);
845 dentry
= ERR_PTR(err
);
846 printk(KERN_WARNING
"%s: %s() failed to create pipe %pd/%s (errno = %d)\n",
847 __FILE__
, __func__
, parent
, name
,
851 EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry
);
854 * rpc_unlink - remove a pipe
855 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
857 * After this call, lookups will no longer find the pipe, and any
858 * attempts to read or write using preexisting opens of the pipe will
862 rpc_unlink(struct dentry
*dentry
)
864 struct dentry
*parent
;
868 parent
= dget_parent(dentry
);
869 dir
= parent
->d_inode
;
870 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
871 error
= __rpc_rmpipe(dir
, dentry
);
872 mutex_unlock(&dir
->i_mutex
);
876 EXPORT_SYMBOL_GPL(rpc_unlink
);
879 * rpc_init_pipe_dir_head - initialise a struct rpc_pipe_dir_head
880 * @pdh: pointer to struct rpc_pipe_dir_head
882 void rpc_init_pipe_dir_head(struct rpc_pipe_dir_head
*pdh
)
884 INIT_LIST_HEAD(&pdh
->pdh_entries
);
885 pdh
->pdh_dentry
= NULL
;
887 EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_head
);
890 * rpc_init_pipe_dir_object - initialise a struct rpc_pipe_dir_object
891 * @pdo: pointer to struct rpc_pipe_dir_object
892 * @pdo_ops: pointer to const struct rpc_pipe_dir_object_ops
893 * @pdo_data: pointer to caller-defined data
895 void rpc_init_pipe_dir_object(struct rpc_pipe_dir_object
*pdo
,
896 const struct rpc_pipe_dir_object_ops
*pdo_ops
,
899 INIT_LIST_HEAD(&pdo
->pdo_head
);
900 pdo
->pdo_ops
= pdo_ops
;
901 pdo
->pdo_data
= pdo_data
;
903 EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_object
);
906 rpc_add_pipe_dir_object_locked(struct net
*net
,
907 struct rpc_pipe_dir_head
*pdh
,
908 struct rpc_pipe_dir_object
*pdo
)
913 ret
= pdo
->pdo_ops
->create(pdh
->pdh_dentry
, pdo
);
915 list_add_tail(&pdo
->pdo_head
, &pdh
->pdh_entries
);
920 rpc_remove_pipe_dir_object_locked(struct net
*net
,
921 struct rpc_pipe_dir_head
*pdh
,
922 struct rpc_pipe_dir_object
*pdo
)
925 pdo
->pdo_ops
->destroy(pdh
->pdh_dentry
, pdo
);
926 list_del_init(&pdo
->pdo_head
);
930 * rpc_add_pipe_dir_object - associate a rpc_pipe_dir_object to a directory
931 * @net: pointer to struct net
932 * @pdh: pointer to struct rpc_pipe_dir_head
933 * @pdo: pointer to struct rpc_pipe_dir_object
937 rpc_add_pipe_dir_object(struct net
*net
,
938 struct rpc_pipe_dir_head
*pdh
,
939 struct rpc_pipe_dir_object
*pdo
)
943 if (list_empty(&pdo
->pdo_head
)) {
944 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
946 mutex_lock(&sn
->pipefs_sb_lock
);
947 ret
= rpc_add_pipe_dir_object_locked(net
, pdh
, pdo
);
948 mutex_unlock(&sn
->pipefs_sb_lock
);
952 EXPORT_SYMBOL_GPL(rpc_add_pipe_dir_object
);
955 * rpc_remove_pipe_dir_object - remove a rpc_pipe_dir_object from a directory
956 * @net: pointer to struct net
957 * @pdh: pointer to struct rpc_pipe_dir_head
958 * @pdo: pointer to struct rpc_pipe_dir_object
962 rpc_remove_pipe_dir_object(struct net
*net
,
963 struct rpc_pipe_dir_head
*pdh
,
964 struct rpc_pipe_dir_object
*pdo
)
966 if (!list_empty(&pdo
->pdo_head
)) {
967 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
969 mutex_lock(&sn
->pipefs_sb_lock
);
970 rpc_remove_pipe_dir_object_locked(net
, pdh
, pdo
);
971 mutex_unlock(&sn
->pipefs_sb_lock
);
974 EXPORT_SYMBOL_GPL(rpc_remove_pipe_dir_object
);
977 * rpc_find_or_alloc_pipe_dir_object
978 * @net: pointer to struct net
979 * @pdh: pointer to struct rpc_pipe_dir_head
980 * @match: match struct rpc_pipe_dir_object to data
981 * @alloc: allocate a new struct rpc_pipe_dir_object
982 * @data: user defined data for match() and alloc()
985 struct rpc_pipe_dir_object
*
986 rpc_find_or_alloc_pipe_dir_object(struct net
*net
,
987 struct rpc_pipe_dir_head
*pdh
,
988 int (*match
)(struct rpc_pipe_dir_object
*, void *),
989 struct rpc_pipe_dir_object
*(*alloc
)(void *),
992 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
993 struct rpc_pipe_dir_object
*pdo
;
995 mutex_lock(&sn
->pipefs_sb_lock
);
996 list_for_each_entry(pdo
, &pdh
->pdh_entries
, pdo_head
) {
997 if (!match(pdo
, data
))
1004 rpc_add_pipe_dir_object_locked(net
, pdh
, pdo
);
1006 mutex_unlock(&sn
->pipefs_sb_lock
);
1009 EXPORT_SYMBOL_GPL(rpc_find_or_alloc_pipe_dir_object
);
1012 rpc_create_pipe_dir_objects(struct rpc_pipe_dir_head
*pdh
)
1014 struct rpc_pipe_dir_object
*pdo
;
1015 struct dentry
*dir
= pdh
->pdh_dentry
;
1017 list_for_each_entry(pdo
, &pdh
->pdh_entries
, pdo_head
)
1018 pdo
->pdo_ops
->create(dir
, pdo
);
1022 rpc_destroy_pipe_dir_objects(struct rpc_pipe_dir_head
*pdh
)
1024 struct rpc_pipe_dir_object
*pdo
;
1025 struct dentry
*dir
= pdh
->pdh_dentry
;
1027 list_for_each_entry(pdo
, &pdh
->pdh_entries
, pdo_head
)
1028 pdo
->pdo_ops
->destroy(dir
, pdo
);
1036 static const struct rpc_filelist authfiles
[] = {
1039 .i_fop
= &rpc_info_operations
,
1040 .mode
= S_IFREG
| S_IRUSR
,
1044 static int rpc_clntdir_populate(struct dentry
*dentry
, void *private)
1046 return rpc_populate(dentry
,
1047 authfiles
, RPCAUTH_info
, RPCAUTH_EOF
,
1051 static void rpc_clntdir_depopulate(struct dentry
*dentry
)
1053 rpc_depopulate(dentry
, authfiles
, RPCAUTH_info
, RPCAUTH_EOF
);
1057 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
1058 * @dentry: the parent of new directory
1059 * @name: the name of new directory
1060 * @rpc_client: rpc client to associate with this directory
1062 * This creates a directory at the given @path associated with
1063 * @rpc_clnt, which will contain a file named "info" with some basic
1064 * information about the client, together with any "pipes" that may
1065 * later be created using rpc_mkpipe().
1067 struct dentry
*rpc_create_client_dir(struct dentry
*dentry
,
1069 struct rpc_clnt
*rpc_client
)
1073 ret
= rpc_mkdir_populate(dentry
, name
, S_IRUGO
| S_IXUGO
, NULL
,
1074 rpc_clntdir_populate
, rpc_client
);
1076 rpc_client
->cl_pipedir_objects
.pdh_dentry
= ret
;
1077 rpc_create_pipe_dir_objects(&rpc_client
->cl_pipedir_objects
);
1083 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
1084 * @rpc_client: rpc_client for the pipe
1086 int rpc_remove_client_dir(struct rpc_clnt
*rpc_client
)
1088 struct dentry
*dentry
= rpc_client
->cl_pipedir_objects
.pdh_dentry
;
1092 rpc_destroy_pipe_dir_objects(&rpc_client
->cl_pipedir_objects
);
1093 rpc_client
->cl_pipedir_objects
.pdh_dentry
= NULL
;
1094 return rpc_rmdir_depopulate(dentry
, rpc_clntdir_depopulate
);
1097 static const struct rpc_filelist cache_pipefs_files
[3] = {
1100 .i_fop
= &cache_file_operations_pipefs
,
1101 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
1105 .i_fop
= &content_file_operations_pipefs
,
1106 .mode
= S_IFREG
|S_IRUSR
,
1110 .i_fop
= &cache_flush_operations_pipefs
,
1111 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
1115 static int rpc_cachedir_populate(struct dentry
*dentry
, void *private)
1117 return rpc_populate(dentry
,
1118 cache_pipefs_files
, 0, 3,
1122 static void rpc_cachedir_depopulate(struct dentry
*dentry
)
1124 rpc_depopulate(dentry
, cache_pipefs_files
, 0, 3);
1127 struct dentry
*rpc_create_cache_dir(struct dentry
*parent
, const char *name
,
1128 umode_t umode
, struct cache_detail
*cd
)
1130 return rpc_mkdir_populate(parent
, name
, umode
, NULL
,
1131 rpc_cachedir_populate
, cd
);
1134 void rpc_remove_cache_dir(struct dentry
*dentry
)
1136 rpc_rmdir_depopulate(dentry
, rpc_cachedir_depopulate
);
1140 * populate the filesystem
1142 static const struct super_operations s_ops
= {
1143 .alloc_inode
= rpc_alloc_inode
,
1144 .destroy_inode
= rpc_destroy_inode
,
1145 .statfs
= simple_statfs
,
1148 #define RPCAUTH_GSSMAGIC 0x67596969
1151 * We have a single directory with 1 node in it.
1165 static const struct rpc_filelist files
[] = {
1168 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1172 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1176 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1178 [RPCAUTH_portmap
] = {
1180 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1184 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1186 [RPCAUTH_nfsd4_cb
] = {
1188 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1192 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1196 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1201 * This call can be used only in RPC pipefs mount notification hooks.
1203 struct dentry
*rpc_d_lookup_sb(const struct super_block
*sb
,
1204 const unsigned char *dir_name
)
1206 struct qstr dir
= QSTR_INIT(dir_name
, strlen(dir_name
));
1207 return d_hash_and_lookup(sb
->s_root
, &dir
);
1209 EXPORT_SYMBOL_GPL(rpc_d_lookup_sb
);
1211 void rpc_pipefs_init_net(struct net
*net
)
1213 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1215 mutex_init(&sn
->pipefs_sb_lock
);
1216 sn
->gssd_running
= 1;
1217 sn
->pipe_version
= -1;
1221 * This call will be used for per network namespace operations calls.
1222 * Note: Function will be returned with pipefs_sb_lock taken if superblock was
1223 * found. This lock have to be released by rpc_put_sb_net() when all operations
1224 * will be completed.
1226 struct super_block
*rpc_get_sb_net(const struct net
*net
)
1228 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1230 mutex_lock(&sn
->pipefs_sb_lock
);
1232 return sn
->pipefs_sb
;
1233 mutex_unlock(&sn
->pipefs_sb_lock
);
1236 EXPORT_SYMBOL_GPL(rpc_get_sb_net
);
1238 void rpc_put_sb_net(const struct net
*net
)
1240 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1242 WARN_ON(sn
->pipefs_sb
== NULL
);
1243 mutex_unlock(&sn
->pipefs_sb_lock
);
1245 EXPORT_SYMBOL_GPL(rpc_put_sb_net
);
1248 rpc_fill_super(struct super_block
*sb
, void *data
, int silent
)
1250 struct inode
*inode
;
1251 struct dentry
*root
;
1252 struct net
*net
= data
;
1253 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1256 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
1257 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
1258 sb
->s_magic
= RPCAUTH_GSSMAGIC
;
1260 sb
->s_d_op
= &simple_dentry_operations
;
1261 sb
->s_time_gran
= 1;
1263 inode
= rpc_get_inode(sb
, S_IFDIR
| S_IRUGO
| S_IXUGO
);
1264 sb
->s_root
= root
= d_make_root(inode
);
1267 if (rpc_populate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
, NULL
))
1269 dprintk("RPC: sending pipefs MOUNT notification for net %p%s\n",
1270 net
, NET_NAME(net
));
1271 mutex_lock(&sn
->pipefs_sb_lock
);
1273 err
= blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1277 goto err_depopulate
;
1278 sb
->s_fs_info
= get_net(net
);
1279 mutex_unlock(&sn
->pipefs_sb_lock
);
1283 blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1286 sn
->pipefs_sb
= NULL
;
1287 __rpc_depopulate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
);
1288 mutex_unlock(&sn
->pipefs_sb_lock
);
1292 static struct dentry
*
1293 rpc_mount(struct file_system_type
*fs_type
,
1294 int flags
, const char *dev_name
, void *data
)
1296 return mount_ns(fs_type
, flags
, current
->nsproxy
->net_ns
, rpc_fill_super
);
1299 static void rpc_kill_sb(struct super_block
*sb
)
1301 struct net
*net
= sb
->s_fs_info
;
1302 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1304 mutex_lock(&sn
->pipefs_sb_lock
);
1305 if (sn
->pipefs_sb
!= sb
) {
1306 mutex_unlock(&sn
->pipefs_sb_lock
);
1309 sn
->pipefs_sb
= NULL
;
1310 dprintk("RPC: sending pipefs UMOUNT notification for net %p%s\n",
1311 net
, NET_NAME(net
));
1312 blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1315 mutex_unlock(&sn
->pipefs_sb_lock
);
1318 kill_litter_super(sb
);
1321 static struct file_system_type rpc_pipe_fs_type
= {
1322 .owner
= THIS_MODULE
,
1323 .name
= "rpc_pipefs",
1325 .kill_sb
= rpc_kill_sb
,
1327 MODULE_ALIAS_FS("rpc_pipefs");
1328 MODULE_ALIAS("rpc_pipefs");
1331 init_once(void *foo
)
1333 struct rpc_inode
*rpci
= (struct rpc_inode
*) foo
;
1335 inode_init_once(&rpci
->vfs_inode
);
1336 rpci
->private = NULL
;
1338 init_waitqueue_head(&rpci
->waitq
);
1341 int register_rpc_pipefs(void)
1345 rpc_inode_cachep
= kmem_cache_create("rpc_inode_cache",
1346 sizeof(struct rpc_inode
),
1347 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
1350 if (!rpc_inode_cachep
)
1352 err
= rpc_clients_notifier_register();
1355 err
= register_filesystem(&rpc_pipe_fs_type
);
1361 rpc_clients_notifier_unregister();
1363 kmem_cache_destroy(rpc_inode_cachep
);
1367 void unregister_rpc_pipefs(void)
1369 rpc_clients_notifier_unregister();
1370 kmem_cache_destroy(rpc_inode_cachep
);
1371 unregister_filesystem(&rpc_pipe_fs_type
);