1 // SPDX-License-Identifier: GPL-2.0-only
3 * net/sunrpc/rpc_pipe.c
5 * Userland/kernel interface for rpcauth_gss.
6 * Code shamelessly plagiarized from fs/nfsd/nfsctl.c
9 * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/string.h>
15 #include <linux/pagemap.h>
16 #include <linux/mount.h>
17 #include <linux/fs_context.h>
18 #include <linux/namei.h>
19 #include <linux/fsnotify.h>
20 #include <linux/kernel.h>
21 #include <linux/rcupdate.h>
22 #include <linux/utsname.h>
24 #include <asm/ioctls.h>
25 #include <linux/poll.h>
26 #include <linux/wait.h>
27 #include <linux/seq_file.h>
29 #include <linux/sunrpc/clnt.h>
30 #include <linux/workqueue.h>
31 #include <linux/sunrpc/rpc_pipe_fs.h>
32 #include <linux/sunrpc/cache.h>
33 #include <linux/nsproxy.h>
34 #include <linux/notifier.h>
39 #define RPCDBG_FACILITY RPCDBG_DEBUG
41 #define NET_NAME(net) ((net == &init_net) ? " (init_net)" : "")
43 static struct file_system_type rpc_pipe_fs_type
;
44 static const struct rpc_pipe_ops gssd_dummy_pipe_ops
;
46 static struct kmem_cache
*rpc_inode_cachep __read_mostly
;
48 #define RPC_UPCALL_TIMEOUT (30*HZ)
50 static BLOCKING_NOTIFIER_HEAD(rpc_pipefs_notifier_list
);
52 int rpc_pipefs_notifier_register(struct notifier_block
*nb
)
54 return blocking_notifier_chain_register(&rpc_pipefs_notifier_list
, nb
);
56 EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_register
);
58 void rpc_pipefs_notifier_unregister(struct notifier_block
*nb
)
60 blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list
, nb
);
62 EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_unregister
);
64 static void rpc_purge_list(wait_queue_head_t
*waitq
, struct list_head
*head
,
65 void (*destroy_msg
)(struct rpc_pipe_msg
*), int err
)
67 struct rpc_pipe_msg
*msg
;
72 msg
= list_entry(head
->next
, struct rpc_pipe_msg
, list
);
73 list_del_init(&msg
->list
);
76 } while (!list_empty(head
));
83 rpc_timeout_upcall_queue(struct work_struct
*work
)
86 struct rpc_pipe
*pipe
=
87 container_of(work
, struct rpc_pipe
, queue_timeout
.work
);
88 void (*destroy_msg
)(struct rpc_pipe_msg
*);
89 struct dentry
*dentry
;
91 spin_lock(&pipe
->lock
);
92 destroy_msg
= pipe
->ops
->destroy_msg
;
93 if (pipe
->nreaders
== 0) {
94 list_splice_init(&pipe
->pipe
, &free_list
);
97 dentry
= dget(pipe
->dentry
);
98 spin_unlock(&pipe
->lock
);
99 rpc_purge_list(dentry
? &RPC_I(d_inode(dentry
))->waitq
: NULL
,
100 &free_list
, destroy_msg
, -ETIMEDOUT
);
104 ssize_t
rpc_pipe_generic_upcall(struct file
*filp
, struct rpc_pipe_msg
*msg
,
105 char __user
*dst
, size_t buflen
)
107 char *data
= (char *)msg
->data
+ msg
->copied
;
108 size_t mlen
= min(msg
->len
- msg
->copied
, buflen
);
111 left
= copy_to_user(dst
, data
, mlen
);
113 msg
->errno
= -EFAULT
;
122 EXPORT_SYMBOL_GPL(rpc_pipe_generic_upcall
);
125 * rpc_queue_upcall - queue an upcall message to userspace
126 * @pipe: upcall pipe on which to queue given message
127 * @msg: message to queue
129 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
130 * A userspace process may then later read the upcall by performing a
131 * read on an open file for this inode. It is up to the caller to
132 * initialize the fields of @msg (other than @msg->list) appropriately.
135 rpc_queue_upcall(struct rpc_pipe
*pipe
, struct rpc_pipe_msg
*msg
)
138 struct dentry
*dentry
;
140 spin_lock(&pipe
->lock
);
141 if (pipe
->nreaders
) {
142 list_add_tail(&msg
->list
, &pipe
->pipe
);
143 pipe
->pipelen
+= msg
->len
;
145 } else if (pipe
->flags
& RPC_PIPE_WAIT_FOR_OPEN
) {
146 if (list_empty(&pipe
->pipe
))
147 queue_delayed_work(rpciod_workqueue
,
148 &pipe
->queue_timeout
,
150 list_add_tail(&msg
->list
, &pipe
->pipe
);
151 pipe
->pipelen
+= msg
->len
;
154 dentry
= dget(pipe
->dentry
);
155 spin_unlock(&pipe
->lock
);
157 wake_up(&RPC_I(d_inode(dentry
))->waitq
);
162 EXPORT_SYMBOL_GPL(rpc_queue_upcall
);
165 rpc_inode_setowner(struct inode
*inode
, void *private)
167 RPC_I(inode
)->private = private;
171 rpc_close_pipes(struct inode
*inode
)
173 struct rpc_pipe
*pipe
= RPC_I(inode
)->pipe
;
175 LIST_HEAD(free_list
);
178 spin_lock(&pipe
->lock
);
179 need_release
= pipe
->nreaders
!= 0 || pipe
->nwriters
!= 0;
181 list_splice_init(&pipe
->in_upcall
, &free_list
);
182 list_splice_init(&pipe
->pipe
, &free_list
);
185 spin_unlock(&pipe
->lock
);
186 rpc_purge_list(&RPC_I(inode
)->waitq
, &free_list
, pipe
->ops
->destroy_msg
, -EPIPE
);
188 if (need_release
&& pipe
->ops
->release_pipe
)
189 pipe
->ops
->release_pipe(inode
);
190 cancel_delayed_work_sync(&pipe
->queue_timeout
);
191 rpc_inode_setowner(inode
, NULL
);
192 RPC_I(inode
)->pipe
= NULL
;
196 static struct inode
*
197 rpc_alloc_inode(struct super_block
*sb
)
199 struct rpc_inode
*rpci
;
200 rpci
= kmem_cache_alloc(rpc_inode_cachep
, GFP_KERNEL
);
203 return &rpci
->vfs_inode
;
207 rpc_free_inode(struct inode
*inode
)
209 kmem_cache_free(rpc_inode_cachep
, RPC_I(inode
));
213 rpc_pipe_open(struct inode
*inode
, struct file
*filp
)
215 struct rpc_pipe
*pipe
;
220 pipe
= RPC_I(inode
)->pipe
;
223 first_open
= pipe
->nreaders
== 0 && pipe
->nwriters
== 0;
224 if (first_open
&& pipe
->ops
->open_pipe
) {
225 res
= pipe
->ops
->open_pipe(inode
);
229 if (filp
->f_mode
& FMODE_READ
)
231 if (filp
->f_mode
& FMODE_WRITE
)
240 rpc_pipe_release(struct inode
*inode
, struct file
*filp
)
242 struct rpc_pipe
*pipe
;
243 struct rpc_pipe_msg
*msg
;
247 pipe
= RPC_I(inode
)->pipe
;
250 msg
= filp
->private_data
;
252 spin_lock(&pipe
->lock
);
253 msg
->errno
= -EAGAIN
;
254 list_del_init(&msg
->list
);
255 spin_unlock(&pipe
->lock
);
256 pipe
->ops
->destroy_msg(msg
);
258 if (filp
->f_mode
& FMODE_WRITE
)
260 if (filp
->f_mode
& FMODE_READ
) {
262 if (pipe
->nreaders
== 0) {
263 LIST_HEAD(free_list
);
264 spin_lock(&pipe
->lock
);
265 list_splice_init(&pipe
->pipe
, &free_list
);
267 spin_unlock(&pipe
->lock
);
268 rpc_purge_list(&RPC_I(inode
)->waitq
, &free_list
,
269 pipe
->ops
->destroy_msg
, -EAGAIN
);
272 last_close
= pipe
->nwriters
== 0 && pipe
->nreaders
== 0;
273 if (last_close
&& pipe
->ops
->release_pipe
)
274 pipe
->ops
->release_pipe(inode
);
281 rpc_pipe_read(struct file
*filp
, char __user
*buf
, size_t len
, loff_t
*offset
)
283 struct inode
*inode
= file_inode(filp
);
284 struct rpc_pipe
*pipe
;
285 struct rpc_pipe_msg
*msg
;
289 pipe
= RPC_I(inode
)->pipe
;
294 msg
= filp
->private_data
;
296 spin_lock(&pipe
->lock
);
297 if (!list_empty(&pipe
->pipe
)) {
298 msg
= list_entry(pipe
->pipe
.next
,
301 list_move(&msg
->list
, &pipe
->in_upcall
);
302 pipe
->pipelen
-= msg
->len
;
303 filp
->private_data
= msg
;
306 spin_unlock(&pipe
->lock
);
310 /* NOTE: it is up to the callback to update msg->copied */
311 res
= pipe
->ops
->upcall(filp
, msg
, buf
, len
);
312 if (res
< 0 || msg
->len
== msg
->copied
) {
313 filp
->private_data
= NULL
;
314 spin_lock(&pipe
->lock
);
315 list_del_init(&msg
->list
);
316 spin_unlock(&pipe
->lock
);
317 pipe
->ops
->destroy_msg(msg
);
325 rpc_pipe_write(struct file
*filp
, const char __user
*buf
, size_t len
, loff_t
*offset
)
327 struct inode
*inode
= file_inode(filp
);
332 if (RPC_I(inode
)->pipe
!= NULL
)
333 res
= RPC_I(inode
)->pipe
->ops
->downcall(filp
, buf
, len
);
339 rpc_pipe_poll(struct file
*filp
, struct poll_table_struct
*wait
)
341 struct inode
*inode
= file_inode(filp
);
342 struct rpc_inode
*rpci
= RPC_I(inode
);
343 __poll_t mask
= EPOLLOUT
| EPOLLWRNORM
;
345 poll_wait(filp
, &rpci
->waitq
, wait
);
348 if (rpci
->pipe
== NULL
)
349 mask
|= EPOLLERR
| EPOLLHUP
;
350 else if (filp
->private_data
|| !list_empty(&rpci
->pipe
->pipe
))
351 mask
|= EPOLLIN
| EPOLLRDNORM
;
357 rpc_pipe_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
359 struct inode
*inode
= file_inode(filp
);
360 struct rpc_pipe
*pipe
;
366 pipe
= RPC_I(inode
)->pipe
;
371 spin_lock(&pipe
->lock
);
373 if (filp
->private_data
) {
374 struct rpc_pipe_msg
*msg
;
375 msg
= filp
->private_data
;
376 len
+= msg
->len
- msg
->copied
;
378 spin_unlock(&pipe
->lock
);
380 return put_user(len
, (int __user
*)arg
);
386 static const struct file_operations rpc_pipe_fops
= {
387 .owner
= THIS_MODULE
,
389 .read
= rpc_pipe_read
,
390 .write
= rpc_pipe_write
,
391 .poll
= rpc_pipe_poll
,
392 .unlocked_ioctl
= rpc_pipe_ioctl
,
393 .open
= rpc_pipe_open
,
394 .release
= rpc_pipe_release
,
398 rpc_show_info(struct seq_file
*m
, void *v
)
400 struct rpc_clnt
*clnt
= m
->private;
403 seq_printf(m
, "RPC server: %s\n",
404 rcu_dereference(clnt
->cl_xprt
)->servername
);
405 seq_printf(m
, "service: %s (%d) version %d\n", clnt
->cl_program
->name
,
406 clnt
->cl_prog
, clnt
->cl_vers
);
407 seq_printf(m
, "address: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_ADDR
));
408 seq_printf(m
, "protocol: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PROTO
));
409 seq_printf(m
, "port: %s\n", rpc_peeraddr2str(clnt
, RPC_DISPLAY_PORT
));
415 rpc_info_open(struct inode
*inode
, struct file
*file
)
417 struct rpc_clnt
*clnt
= NULL
;
418 int ret
= single_open(file
, rpc_show_info
, NULL
);
421 struct seq_file
*m
= file
->private_data
;
423 spin_lock(&file
->f_path
.dentry
->d_lock
);
424 if (!d_unhashed(file
->f_path
.dentry
))
425 clnt
= RPC_I(inode
)->private;
426 if (clnt
!= NULL
&& refcount_inc_not_zero(&clnt
->cl_count
)) {
427 spin_unlock(&file
->f_path
.dentry
->d_lock
);
430 spin_unlock(&file
->f_path
.dentry
->d_lock
);
431 single_release(inode
, file
);
439 rpc_info_release(struct inode
*inode
, struct file
*file
)
441 struct seq_file
*m
= file
->private_data
;
442 struct rpc_clnt
*clnt
= (struct rpc_clnt
*)m
->private;
445 rpc_release_client(clnt
);
446 return single_release(inode
, file
);
449 static const struct file_operations rpc_info_operations
= {
450 .owner
= THIS_MODULE
,
451 .open
= rpc_info_open
,
454 .release
= rpc_info_release
,
459 * Description of fs contents.
461 struct rpc_filelist
{
463 const struct file_operations
*i_fop
;
467 static struct inode
*
468 rpc_get_inode(struct super_block
*sb
, umode_t mode
)
470 struct inode
*inode
= new_inode(sb
);
473 inode
->i_ino
= get_next_ino();
474 inode
->i_mode
= mode
;
475 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
476 switch (mode
& S_IFMT
) {
478 inode
->i_fop
= &simple_dir_operations
;
479 inode
->i_op
= &simple_dir_inode_operations
;
488 static int __rpc_create_common(struct inode
*dir
, struct dentry
*dentry
,
490 const struct file_operations
*i_fop
,
496 inode
= rpc_get_inode(dir
->i_sb
, mode
);
499 inode
->i_ino
= iunique(dir
->i_sb
, 100);
501 inode
->i_fop
= i_fop
;
503 rpc_inode_setowner(inode
, private);
504 d_add(dentry
, inode
);
507 printk(KERN_WARNING
"%s: %s failed to allocate inode for dentry %pd\n",
508 __FILE__
, __func__
, dentry
);
513 static int __rpc_create(struct inode
*dir
, struct dentry
*dentry
,
515 const struct file_operations
*i_fop
,
520 err
= __rpc_create_common(dir
, dentry
, S_IFREG
| mode
, i_fop
, private);
523 fsnotify_create(dir
, dentry
);
527 static int __rpc_mkdir(struct inode
*dir
, struct dentry
*dentry
,
529 const struct file_operations
*i_fop
,
534 err
= __rpc_create_common(dir
, dentry
, S_IFDIR
| mode
, i_fop
, private);
538 fsnotify_mkdir(dir
, dentry
);
543 init_pipe(struct rpc_pipe
*pipe
)
547 INIT_LIST_HEAD(&pipe
->in_upcall
);
548 INIT_LIST_HEAD(&pipe
->in_downcall
);
549 INIT_LIST_HEAD(&pipe
->pipe
);
551 INIT_DELAYED_WORK(&pipe
->queue_timeout
,
552 rpc_timeout_upcall_queue
);
554 spin_lock_init(&pipe
->lock
);
558 void rpc_destroy_pipe_data(struct rpc_pipe
*pipe
)
562 EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data
);
564 struct rpc_pipe
*rpc_mkpipe_data(const struct rpc_pipe_ops
*ops
, int flags
)
566 struct rpc_pipe
*pipe
;
568 pipe
= kzalloc(sizeof(struct rpc_pipe
), GFP_KERNEL
);
570 return ERR_PTR(-ENOMEM
);
576 EXPORT_SYMBOL_GPL(rpc_mkpipe_data
);
578 static int __rpc_mkpipe_dentry(struct inode
*dir
, struct dentry
*dentry
,
580 const struct file_operations
*i_fop
,
582 struct rpc_pipe
*pipe
)
584 struct rpc_inode
*rpci
;
587 err
= __rpc_create_common(dir
, dentry
, S_IFIFO
| mode
, i_fop
, private);
590 rpci
= RPC_I(d_inode(dentry
));
591 rpci
->private = private;
593 fsnotify_create(dir
, dentry
);
597 static int __rpc_rmdir(struct inode
*dir
, struct dentry
*dentry
)
602 ret
= simple_rmdir(dir
, dentry
);
605 fsnotify_rmdir(dir
, dentry
);
610 static int __rpc_unlink(struct inode
*dir
, struct dentry
*dentry
)
615 ret
= simple_unlink(dir
, dentry
);
618 fsnotify_unlink(dir
, dentry
);
623 static int __rpc_rmpipe(struct inode
*dir
, struct dentry
*dentry
)
625 struct inode
*inode
= d_inode(dentry
);
627 rpc_close_pipes(inode
);
628 return __rpc_unlink(dir
, dentry
);
631 static struct dentry
*__rpc_lookup_create_exclusive(struct dentry
*parent
,
634 struct qstr q
= QSTR_INIT(name
, strlen(name
));
635 struct dentry
*dentry
= d_hash_and_lookup(parent
, &q
);
637 dentry
= d_alloc(parent
, &q
);
639 return ERR_PTR(-ENOMEM
);
641 if (d_really_is_negative(dentry
))
644 return ERR_PTR(-EEXIST
);
648 * FIXME: This probably has races.
650 static void __rpc_depopulate(struct dentry
*parent
,
651 const struct rpc_filelist
*files
,
654 struct inode
*dir
= d_inode(parent
);
655 struct dentry
*dentry
;
659 for (i
= start
; i
< eof
; i
++) {
660 name
.name
= files
[i
].name
;
661 name
.len
= strlen(files
[i
].name
);
662 dentry
= d_hash_and_lookup(parent
, &name
);
666 if (d_really_is_negative(dentry
))
668 switch (d_inode(dentry
)->i_mode
& S_IFMT
) {
672 __rpc_unlink(dir
, dentry
);
675 __rpc_rmdir(dir
, dentry
);
682 static void rpc_depopulate(struct dentry
*parent
,
683 const struct rpc_filelist
*files
,
686 struct inode
*dir
= d_inode(parent
);
688 inode_lock_nested(dir
, I_MUTEX_CHILD
);
689 __rpc_depopulate(parent
, files
, start
, eof
);
693 static int rpc_populate(struct dentry
*parent
,
694 const struct rpc_filelist
*files
,
698 struct inode
*dir
= d_inode(parent
);
699 struct dentry
*dentry
;
703 for (i
= start
; i
< eof
; i
++) {
704 dentry
= __rpc_lookup_create_exclusive(parent
, files
[i
].name
);
705 err
= PTR_ERR(dentry
);
708 switch (files
[i
].mode
& S_IFMT
) {
712 err
= __rpc_create(dir
, dentry
,
718 err
= __rpc_mkdir(dir
, dentry
,
729 __rpc_depopulate(parent
, files
, start
, eof
);
731 printk(KERN_WARNING
"%s: %s failed to populate directory %pd\n",
732 __FILE__
, __func__
, parent
);
736 static struct dentry
*rpc_mkdir_populate(struct dentry
*parent
,
737 const char *name
, umode_t mode
, void *private,
738 int (*populate
)(struct dentry
*, void *), void *args_populate
)
740 struct dentry
*dentry
;
741 struct inode
*dir
= d_inode(parent
);
744 inode_lock_nested(dir
, I_MUTEX_PARENT
);
745 dentry
= __rpc_lookup_create_exclusive(parent
, name
);
748 error
= __rpc_mkdir(dir
, dentry
, mode
, NULL
, private);
751 if (populate
!= NULL
) {
752 error
= populate(dentry
, args_populate
);
760 __rpc_rmdir(dir
, dentry
);
762 dentry
= ERR_PTR(error
);
766 static int rpc_rmdir_depopulate(struct dentry
*dentry
,
767 void (*depopulate
)(struct dentry
*))
769 struct dentry
*parent
;
773 parent
= dget_parent(dentry
);
774 dir
= d_inode(parent
);
775 inode_lock_nested(dir
, I_MUTEX_PARENT
);
776 if (depopulate
!= NULL
)
778 error
= __rpc_rmdir(dir
, dentry
);
785 * rpc_mkpipe_dentry - make an rpc_pipefs file for kernel<->userspace
787 * @parent: dentry of directory to create new "pipe" in
788 * @name: name of pipe
789 * @private: private data to associate with the pipe, for the caller's use
790 * @pipe: &rpc_pipe containing input parameters
792 * Data is made available for userspace to read by calls to
793 * rpc_queue_upcall(). The actual reads will result in calls to
794 * @ops->upcall, which will be called with the file pointer,
795 * message, and userspace buffer to copy to.
797 * Writes can come at any time, and do not necessarily have to be
798 * responses to upcalls. They will result in calls to @msg->downcall.
800 * The @private argument passed here will be available to all these methods
801 * from the file pointer, via RPC_I(file_inode(file))->private.
803 struct dentry
*rpc_mkpipe_dentry(struct dentry
*parent
, const char *name
,
804 void *private, struct rpc_pipe
*pipe
)
806 struct dentry
*dentry
;
807 struct inode
*dir
= d_inode(parent
);
808 umode_t umode
= S_IFIFO
| 0600;
811 if (pipe
->ops
->upcall
== NULL
)
813 if (pipe
->ops
->downcall
== NULL
)
816 inode_lock_nested(dir
, I_MUTEX_PARENT
);
817 dentry
= __rpc_lookup_create_exclusive(parent
, name
);
820 err
= __rpc_mkpipe_dentry(dir
, dentry
, umode
, &rpc_pipe_fops
,
828 dentry
= ERR_PTR(err
);
829 printk(KERN_WARNING
"%s: %s() failed to create pipe %pd/%s (errno = %d)\n",
830 __FILE__
, __func__
, parent
, name
,
834 EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry
);
837 * rpc_unlink - remove a pipe
838 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
840 * After this call, lookups will no longer find the pipe, and any
841 * attempts to read or write using preexisting opens of the pipe will
845 rpc_unlink(struct dentry
*dentry
)
847 struct dentry
*parent
;
851 parent
= dget_parent(dentry
);
852 dir
= d_inode(parent
);
853 inode_lock_nested(dir
, I_MUTEX_PARENT
);
854 error
= __rpc_rmpipe(dir
, dentry
);
859 EXPORT_SYMBOL_GPL(rpc_unlink
);
862 * rpc_init_pipe_dir_head - initialise a struct rpc_pipe_dir_head
863 * @pdh: pointer to struct rpc_pipe_dir_head
865 void rpc_init_pipe_dir_head(struct rpc_pipe_dir_head
*pdh
)
867 INIT_LIST_HEAD(&pdh
->pdh_entries
);
868 pdh
->pdh_dentry
= NULL
;
870 EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_head
);
873 * rpc_init_pipe_dir_object - initialise a struct rpc_pipe_dir_object
874 * @pdo: pointer to struct rpc_pipe_dir_object
875 * @pdo_ops: pointer to const struct rpc_pipe_dir_object_ops
876 * @pdo_data: pointer to caller-defined data
878 void rpc_init_pipe_dir_object(struct rpc_pipe_dir_object
*pdo
,
879 const struct rpc_pipe_dir_object_ops
*pdo_ops
,
882 INIT_LIST_HEAD(&pdo
->pdo_head
);
883 pdo
->pdo_ops
= pdo_ops
;
884 pdo
->pdo_data
= pdo_data
;
886 EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_object
);
889 rpc_add_pipe_dir_object_locked(struct net
*net
,
890 struct rpc_pipe_dir_head
*pdh
,
891 struct rpc_pipe_dir_object
*pdo
)
896 ret
= pdo
->pdo_ops
->create(pdh
->pdh_dentry
, pdo
);
898 list_add_tail(&pdo
->pdo_head
, &pdh
->pdh_entries
);
903 rpc_remove_pipe_dir_object_locked(struct net
*net
,
904 struct rpc_pipe_dir_head
*pdh
,
905 struct rpc_pipe_dir_object
*pdo
)
908 pdo
->pdo_ops
->destroy(pdh
->pdh_dentry
, pdo
);
909 list_del_init(&pdo
->pdo_head
);
913 * rpc_add_pipe_dir_object - associate a rpc_pipe_dir_object to a directory
914 * @net: pointer to struct net
915 * @pdh: pointer to struct rpc_pipe_dir_head
916 * @pdo: pointer to struct rpc_pipe_dir_object
920 rpc_add_pipe_dir_object(struct net
*net
,
921 struct rpc_pipe_dir_head
*pdh
,
922 struct rpc_pipe_dir_object
*pdo
)
926 if (list_empty(&pdo
->pdo_head
)) {
927 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
929 mutex_lock(&sn
->pipefs_sb_lock
);
930 ret
= rpc_add_pipe_dir_object_locked(net
, pdh
, pdo
);
931 mutex_unlock(&sn
->pipefs_sb_lock
);
935 EXPORT_SYMBOL_GPL(rpc_add_pipe_dir_object
);
938 * rpc_remove_pipe_dir_object - remove a rpc_pipe_dir_object from a directory
939 * @net: pointer to struct net
940 * @pdh: pointer to struct rpc_pipe_dir_head
941 * @pdo: pointer to struct rpc_pipe_dir_object
945 rpc_remove_pipe_dir_object(struct net
*net
,
946 struct rpc_pipe_dir_head
*pdh
,
947 struct rpc_pipe_dir_object
*pdo
)
949 if (!list_empty(&pdo
->pdo_head
)) {
950 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
952 mutex_lock(&sn
->pipefs_sb_lock
);
953 rpc_remove_pipe_dir_object_locked(net
, pdh
, pdo
);
954 mutex_unlock(&sn
->pipefs_sb_lock
);
957 EXPORT_SYMBOL_GPL(rpc_remove_pipe_dir_object
);
960 * rpc_find_or_alloc_pipe_dir_object
961 * @net: pointer to struct net
962 * @pdh: pointer to struct rpc_pipe_dir_head
963 * @match: match struct rpc_pipe_dir_object to data
964 * @alloc: allocate a new struct rpc_pipe_dir_object
965 * @data: user defined data for match() and alloc()
968 struct rpc_pipe_dir_object
*
969 rpc_find_or_alloc_pipe_dir_object(struct net
*net
,
970 struct rpc_pipe_dir_head
*pdh
,
971 int (*match
)(struct rpc_pipe_dir_object
*, void *),
972 struct rpc_pipe_dir_object
*(*alloc
)(void *),
975 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
976 struct rpc_pipe_dir_object
*pdo
;
978 mutex_lock(&sn
->pipefs_sb_lock
);
979 list_for_each_entry(pdo
, &pdh
->pdh_entries
, pdo_head
) {
980 if (!match(pdo
, data
))
987 rpc_add_pipe_dir_object_locked(net
, pdh
, pdo
);
989 mutex_unlock(&sn
->pipefs_sb_lock
);
992 EXPORT_SYMBOL_GPL(rpc_find_or_alloc_pipe_dir_object
);
995 rpc_create_pipe_dir_objects(struct rpc_pipe_dir_head
*pdh
)
997 struct rpc_pipe_dir_object
*pdo
;
998 struct dentry
*dir
= pdh
->pdh_dentry
;
1000 list_for_each_entry(pdo
, &pdh
->pdh_entries
, pdo_head
)
1001 pdo
->pdo_ops
->create(dir
, pdo
);
1005 rpc_destroy_pipe_dir_objects(struct rpc_pipe_dir_head
*pdh
)
1007 struct rpc_pipe_dir_object
*pdo
;
1008 struct dentry
*dir
= pdh
->pdh_dentry
;
1010 list_for_each_entry(pdo
, &pdh
->pdh_entries
, pdo_head
)
1011 pdo
->pdo_ops
->destroy(dir
, pdo
);
1019 static const struct rpc_filelist authfiles
[] = {
1022 .i_fop
= &rpc_info_operations
,
1023 .mode
= S_IFREG
| 0400,
1027 static int rpc_clntdir_populate(struct dentry
*dentry
, void *private)
1029 return rpc_populate(dentry
,
1030 authfiles
, RPCAUTH_info
, RPCAUTH_EOF
,
1034 static void rpc_clntdir_depopulate(struct dentry
*dentry
)
1036 rpc_depopulate(dentry
, authfiles
, RPCAUTH_info
, RPCAUTH_EOF
);
1040 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
1041 * @dentry: the parent of new directory
1042 * @name: the name of new directory
1043 * @rpc_client: rpc client to associate with this directory
1045 * This creates a directory at the given @path associated with
1046 * @rpc_clnt, which will contain a file named "info" with some basic
1047 * information about the client, together with any "pipes" that may
1048 * later be created using rpc_mkpipe().
1050 struct dentry
*rpc_create_client_dir(struct dentry
*dentry
,
1052 struct rpc_clnt
*rpc_client
)
1056 ret
= rpc_mkdir_populate(dentry
, name
, 0555, NULL
,
1057 rpc_clntdir_populate
, rpc_client
);
1059 rpc_client
->cl_pipedir_objects
.pdh_dentry
= ret
;
1060 rpc_create_pipe_dir_objects(&rpc_client
->cl_pipedir_objects
);
1066 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
1067 * @rpc_client: rpc_client for the pipe
1069 int rpc_remove_client_dir(struct rpc_clnt
*rpc_client
)
1071 struct dentry
*dentry
= rpc_client
->cl_pipedir_objects
.pdh_dentry
;
1075 rpc_destroy_pipe_dir_objects(&rpc_client
->cl_pipedir_objects
);
1076 rpc_client
->cl_pipedir_objects
.pdh_dentry
= NULL
;
1077 return rpc_rmdir_depopulate(dentry
, rpc_clntdir_depopulate
);
1080 static const struct rpc_filelist cache_pipefs_files
[3] = {
1083 .i_fop
= &cache_file_operations_pipefs
,
1084 .mode
= S_IFREG
| 0600,
1088 .i_fop
= &content_file_operations_pipefs
,
1089 .mode
= S_IFREG
| 0400,
1093 .i_fop
= &cache_flush_operations_pipefs
,
1094 .mode
= S_IFREG
| 0600,
1098 static int rpc_cachedir_populate(struct dentry
*dentry
, void *private)
1100 return rpc_populate(dentry
,
1101 cache_pipefs_files
, 0, 3,
1105 static void rpc_cachedir_depopulate(struct dentry
*dentry
)
1107 rpc_depopulate(dentry
, cache_pipefs_files
, 0, 3);
1110 struct dentry
*rpc_create_cache_dir(struct dentry
*parent
, const char *name
,
1111 umode_t umode
, struct cache_detail
*cd
)
1113 return rpc_mkdir_populate(parent
, name
, umode
, NULL
,
1114 rpc_cachedir_populate
, cd
);
1117 void rpc_remove_cache_dir(struct dentry
*dentry
)
1119 rpc_rmdir_depopulate(dentry
, rpc_cachedir_depopulate
);
1123 * populate the filesystem
1125 static const struct super_operations s_ops
= {
1126 .alloc_inode
= rpc_alloc_inode
,
1127 .free_inode
= rpc_free_inode
,
1128 .statfs
= simple_statfs
,
1131 #define RPCAUTH_GSSMAGIC 0x67596969
1134 * We have a single directory with 1 node in it.
1149 static const struct rpc_filelist files
[] = {
1152 .mode
= S_IFDIR
| 0555,
1156 .mode
= S_IFDIR
| 0555,
1160 .mode
= S_IFDIR
| 0555,
1162 [RPCAUTH_portmap
] = {
1164 .mode
= S_IFDIR
| 0555,
1168 .mode
= S_IFDIR
| 0555,
1170 [RPCAUTH_nfsd4_cb
] = {
1172 .mode
= S_IFDIR
| 0555,
1176 .mode
= S_IFDIR
| 0555,
1180 .mode
= S_IFDIR
| 0555,
1184 .mode
= S_IFDIR
| 0555,
1189 * This call can be used only in RPC pipefs mount notification hooks.
1191 struct dentry
*rpc_d_lookup_sb(const struct super_block
*sb
,
1192 const unsigned char *dir_name
)
1194 struct qstr dir
= QSTR_INIT(dir_name
, strlen(dir_name
));
1195 return d_hash_and_lookup(sb
->s_root
, &dir
);
1197 EXPORT_SYMBOL_GPL(rpc_d_lookup_sb
);
1199 int rpc_pipefs_init_net(struct net
*net
)
1201 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1203 sn
->gssd_dummy
= rpc_mkpipe_data(&gssd_dummy_pipe_ops
, 0);
1204 if (IS_ERR(sn
->gssd_dummy
))
1205 return PTR_ERR(sn
->gssd_dummy
);
1207 mutex_init(&sn
->pipefs_sb_lock
);
1208 sn
->pipe_version
= -1;
1212 void rpc_pipefs_exit_net(struct net
*net
)
1214 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1216 rpc_destroy_pipe_data(sn
->gssd_dummy
);
1220 * This call will be used for per network namespace operations calls.
1221 * Note: Function will be returned with pipefs_sb_lock taken if superblock was
1222 * found. This lock have to be released by rpc_put_sb_net() when all operations
1223 * will be completed.
1225 struct super_block
*rpc_get_sb_net(const struct net
*net
)
1227 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1229 mutex_lock(&sn
->pipefs_sb_lock
);
1231 return sn
->pipefs_sb
;
1232 mutex_unlock(&sn
->pipefs_sb_lock
);
1235 EXPORT_SYMBOL_GPL(rpc_get_sb_net
);
1237 void rpc_put_sb_net(const struct net
*net
)
1239 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1241 WARN_ON(sn
->pipefs_sb
== NULL
);
1242 mutex_unlock(&sn
->pipefs_sb_lock
);
1244 EXPORT_SYMBOL_GPL(rpc_put_sb_net
);
1246 static const struct rpc_filelist gssd_dummy_clnt_dir
[] = {
1249 .mode
= S_IFDIR
| 0555,
1254 dummy_downcall(struct file
*filp
, const char __user
*src
, size_t len
)
1259 static const struct rpc_pipe_ops gssd_dummy_pipe_ops
= {
1260 .upcall
= rpc_pipe_generic_upcall
,
1261 .downcall
= dummy_downcall
,
1265 * Here we present a bogus "info" file to keep rpc.gssd happy. We don't expect
1266 * that it will ever use this info to handle an upcall, but rpc.gssd expects
1267 * that this file will be there and have a certain format.
1270 rpc_dummy_info_show(struct seq_file
*m
, void *v
)
1272 seq_printf(m
, "RPC server: %s\n", utsname()->nodename
);
1273 seq_printf(m
, "service: foo (1) version 0\n");
1274 seq_printf(m
, "address: 127.0.0.1\n");
1275 seq_printf(m
, "protocol: tcp\n");
1276 seq_printf(m
, "port: 0\n");
1279 DEFINE_SHOW_ATTRIBUTE(rpc_dummy_info
);
1281 static const struct rpc_filelist gssd_dummy_info_file
[] = {
1284 .i_fop
= &rpc_dummy_info_fops
,
1285 .mode
= S_IFREG
| 0400,
1290 * rpc_gssd_dummy_populate - create a dummy gssd pipe
1291 * @root: root of the rpc_pipefs filesystem
1292 * @pipe_data: pipe data created when netns is initialized
1294 * Create a dummy set of directories and a pipe that gssd can hold open to
1295 * indicate that it is up and running.
1297 static struct dentry
*
1298 rpc_gssd_dummy_populate(struct dentry
*root
, struct rpc_pipe
*pipe_data
)
1301 struct dentry
*gssd_dentry
;
1302 struct dentry
*clnt_dentry
= NULL
;
1303 struct dentry
*pipe_dentry
= NULL
;
1304 struct qstr q
= QSTR_INIT(files
[RPCAUTH_gssd
].name
,
1305 strlen(files
[RPCAUTH_gssd
].name
));
1307 /* We should never get this far if "gssd" doesn't exist */
1308 gssd_dentry
= d_hash_and_lookup(root
, &q
);
1310 return ERR_PTR(-ENOENT
);
1312 ret
= rpc_populate(gssd_dentry
, gssd_dummy_clnt_dir
, 0, 1, NULL
);
1314 pipe_dentry
= ERR_PTR(ret
);
1318 q
.name
= gssd_dummy_clnt_dir
[0].name
;
1319 q
.len
= strlen(gssd_dummy_clnt_dir
[0].name
);
1320 clnt_dentry
= d_hash_and_lookup(gssd_dentry
, &q
);
1322 __rpc_depopulate(gssd_dentry
, gssd_dummy_clnt_dir
, 0, 1);
1323 pipe_dentry
= ERR_PTR(-ENOENT
);
1327 ret
= rpc_populate(clnt_dentry
, gssd_dummy_info_file
, 0, 1, NULL
);
1329 __rpc_depopulate(gssd_dentry
, gssd_dummy_clnt_dir
, 0, 1);
1330 pipe_dentry
= ERR_PTR(ret
);
1334 pipe_dentry
= rpc_mkpipe_dentry(clnt_dentry
, "gssd", NULL
, pipe_data
);
1335 if (IS_ERR(pipe_dentry
)) {
1336 __rpc_depopulate(clnt_dentry
, gssd_dummy_info_file
, 0, 1);
1337 __rpc_depopulate(gssd_dentry
, gssd_dummy_clnt_dir
, 0, 1);
1346 rpc_gssd_dummy_depopulate(struct dentry
*pipe_dentry
)
1348 struct dentry
*clnt_dir
= pipe_dentry
->d_parent
;
1349 struct dentry
*gssd_dir
= clnt_dir
->d_parent
;
1352 __rpc_rmpipe(d_inode(clnt_dir
), pipe_dentry
);
1353 __rpc_depopulate(clnt_dir
, gssd_dummy_info_file
, 0, 1);
1354 __rpc_depopulate(gssd_dir
, gssd_dummy_clnt_dir
, 0, 1);
1359 rpc_fill_super(struct super_block
*sb
, struct fs_context
*fc
)
1361 struct inode
*inode
;
1362 struct dentry
*root
, *gssd_dentry
;
1363 struct net
*net
= sb
->s_fs_info
;
1364 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1367 sb
->s_blocksize
= PAGE_SIZE
;
1368 sb
->s_blocksize_bits
= PAGE_SHIFT
;
1369 sb
->s_magic
= RPCAUTH_GSSMAGIC
;
1371 sb
->s_d_op
= &simple_dentry_operations
;
1372 sb
->s_time_gran
= 1;
1374 inode
= rpc_get_inode(sb
, S_IFDIR
| 0555);
1375 sb
->s_root
= root
= d_make_root(inode
);
1378 if (rpc_populate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
, NULL
))
1381 gssd_dentry
= rpc_gssd_dummy_populate(root
, sn
->gssd_dummy
);
1382 if (IS_ERR(gssd_dentry
)) {
1383 __rpc_depopulate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
);
1384 return PTR_ERR(gssd_dentry
);
1387 dprintk("RPC: sending pipefs MOUNT notification for net %x%s\n",
1388 net
->ns
.inum
, NET_NAME(net
));
1389 mutex_lock(&sn
->pipefs_sb_lock
);
1391 err
= blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1395 goto err_depopulate
;
1396 mutex_unlock(&sn
->pipefs_sb_lock
);
1400 rpc_gssd_dummy_depopulate(gssd_dentry
);
1401 blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1404 sn
->pipefs_sb
= NULL
;
1405 __rpc_depopulate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
);
1406 mutex_unlock(&sn
->pipefs_sb_lock
);
1411 gssd_running(struct net
*net
)
1413 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1414 struct rpc_pipe
*pipe
= sn
->gssd_dummy
;
1416 return pipe
->nreaders
|| pipe
->nwriters
;
1418 EXPORT_SYMBOL_GPL(gssd_running
);
1420 static int rpc_fs_get_tree(struct fs_context
*fc
)
1422 return get_tree_keyed(fc
, rpc_fill_super
, get_net(fc
->net_ns
));
1425 static void rpc_fs_free_fc(struct fs_context
*fc
)
1428 put_net(fc
->s_fs_info
);
1431 static const struct fs_context_operations rpc_fs_context_ops
= {
1432 .free
= rpc_fs_free_fc
,
1433 .get_tree
= rpc_fs_get_tree
,
1436 static int rpc_init_fs_context(struct fs_context
*fc
)
1438 put_user_ns(fc
->user_ns
);
1439 fc
->user_ns
= get_user_ns(fc
->net_ns
->user_ns
);
1440 fc
->ops
= &rpc_fs_context_ops
;
1444 static void rpc_kill_sb(struct super_block
*sb
)
1446 struct net
*net
= sb
->s_fs_info
;
1447 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1449 mutex_lock(&sn
->pipefs_sb_lock
);
1450 if (sn
->pipefs_sb
!= sb
) {
1451 mutex_unlock(&sn
->pipefs_sb_lock
);
1454 sn
->pipefs_sb
= NULL
;
1455 dprintk("RPC: sending pipefs UMOUNT notification for net %x%s\n",
1456 net
->ns
.inum
, NET_NAME(net
));
1457 blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1460 mutex_unlock(&sn
->pipefs_sb_lock
);
1462 kill_litter_super(sb
);
1466 static struct file_system_type rpc_pipe_fs_type
= {
1467 .owner
= THIS_MODULE
,
1468 .name
= "rpc_pipefs",
1469 .init_fs_context
= rpc_init_fs_context
,
1470 .kill_sb
= rpc_kill_sb
,
1472 MODULE_ALIAS_FS("rpc_pipefs");
1473 MODULE_ALIAS("rpc_pipefs");
1476 init_once(void *foo
)
1478 struct rpc_inode
*rpci
= (struct rpc_inode
*) foo
;
1480 inode_init_once(&rpci
->vfs_inode
);
1481 rpci
->private = NULL
;
1483 init_waitqueue_head(&rpci
->waitq
);
1486 int register_rpc_pipefs(void)
1490 rpc_inode_cachep
= kmem_cache_create("rpc_inode_cache",
1491 sizeof(struct rpc_inode
),
1492 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
1493 SLAB_MEM_SPREAD
|SLAB_ACCOUNT
),
1495 if (!rpc_inode_cachep
)
1497 err
= rpc_clients_notifier_register();
1500 err
= register_filesystem(&rpc_pipe_fs_type
);
1506 rpc_clients_notifier_unregister();
1508 kmem_cache_destroy(rpc_inode_cachep
);
1512 void unregister_rpc_pipefs(void)
1514 rpc_clients_notifier_unregister();
1515 unregister_filesystem(&rpc_pipe_fs_type
);
1516 kmem_cache_destroy(rpc_inode_cachep
);