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_protname
,
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 int rpc_delete_dentry(const struct dentry
*dentry
)
479 static const struct dentry_operations rpc_dentry_operations
= {
480 .d_delete
= rpc_delete_dentry
,
483 static struct inode
*
484 rpc_get_inode(struct super_block
*sb
, umode_t mode
)
486 struct inode
*inode
= new_inode(sb
);
489 inode
->i_ino
= get_next_ino();
490 inode
->i_mode
= mode
;
491 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
492 switch (mode
& S_IFMT
) {
494 inode
->i_fop
= &simple_dir_operations
;
495 inode
->i_op
= &simple_dir_inode_operations
;
503 static int __rpc_create_common(struct inode
*dir
, struct dentry
*dentry
,
505 const struct file_operations
*i_fop
,
511 inode
= rpc_get_inode(dir
->i_sb
, mode
);
514 inode
->i_ino
= iunique(dir
->i_sb
, 100);
516 inode
->i_fop
= i_fop
;
518 rpc_inode_setowner(inode
, private);
519 d_add(dentry
, inode
);
522 printk(KERN_WARNING
"%s: %s failed to allocate inode for dentry %s\n",
523 __FILE__
, __func__
, dentry
->d_name
.name
);
528 static int __rpc_create(struct inode
*dir
, struct dentry
*dentry
,
530 const struct file_operations
*i_fop
,
535 err
= __rpc_create_common(dir
, dentry
, S_IFREG
| mode
, i_fop
, private);
538 fsnotify_create(dir
, dentry
);
542 static int __rpc_mkdir(struct inode
*dir
, struct dentry
*dentry
,
544 const struct file_operations
*i_fop
,
549 err
= __rpc_create_common(dir
, dentry
, S_IFDIR
| mode
, i_fop
, private);
553 fsnotify_mkdir(dir
, dentry
);
558 init_pipe(struct rpc_pipe
*pipe
)
562 INIT_LIST_HEAD(&pipe
->in_upcall
);
563 INIT_LIST_HEAD(&pipe
->in_downcall
);
564 INIT_LIST_HEAD(&pipe
->pipe
);
566 INIT_DELAYED_WORK(&pipe
->queue_timeout
,
567 rpc_timeout_upcall_queue
);
569 spin_lock_init(&pipe
->lock
);
573 void rpc_destroy_pipe_data(struct rpc_pipe
*pipe
)
577 EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data
);
579 struct rpc_pipe
*rpc_mkpipe_data(const struct rpc_pipe_ops
*ops
, int flags
)
581 struct rpc_pipe
*pipe
;
583 pipe
= kzalloc(sizeof(struct rpc_pipe
), GFP_KERNEL
);
585 return ERR_PTR(-ENOMEM
);
591 EXPORT_SYMBOL_GPL(rpc_mkpipe_data
);
593 static int __rpc_mkpipe_dentry(struct inode
*dir
, struct dentry
*dentry
,
595 const struct file_operations
*i_fop
,
597 struct rpc_pipe
*pipe
)
599 struct rpc_inode
*rpci
;
602 err
= __rpc_create_common(dir
, dentry
, S_IFIFO
| mode
, i_fop
, private);
605 rpci
= RPC_I(dentry
->d_inode
);
606 rpci
->private = private;
608 fsnotify_create(dir
, dentry
);
612 static int __rpc_rmdir(struct inode
*dir
, struct dentry
*dentry
)
617 ret
= simple_rmdir(dir
, dentry
);
623 int rpc_rmdir(struct dentry
*dentry
)
625 struct dentry
*parent
;
629 parent
= dget_parent(dentry
);
630 dir
= parent
->d_inode
;
631 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
632 error
= __rpc_rmdir(dir
, dentry
);
633 mutex_unlock(&dir
->i_mutex
);
637 EXPORT_SYMBOL_GPL(rpc_rmdir
);
639 static int __rpc_unlink(struct inode
*dir
, struct dentry
*dentry
)
644 ret
= simple_unlink(dir
, dentry
);
650 static int __rpc_rmpipe(struct inode
*dir
, struct dentry
*dentry
)
652 struct inode
*inode
= dentry
->d_inode
;
654 rpc_close_pipes(inode
);
655 return __rpc_unlink(dir
, dentry
);
658 static struct dentry
*__rpc_lookup_create_exclusive(struct dentry
*parent
,
661 struct dentry
*dentry
;
663 dentry
= d_lookup(parent
, name
);
665 dentry
= d_alloc(parent
, name
);
667 return ERR_PTR(-ENOMEM
);
669 if (dentry
->d_inode
== NULL
) {
670 d_set_d_op(dentry
, &rpc_dentry_operations
);
674 return ERR_PTR(-EEXIST
);
678 * FIXME: This probably has races.
680 static void __rpc_depopulate(struct dentry
*parent
,
681 const struct rpc_filelist
*files
,
684 struct inode
*dir
= parent
->d_inode
;
685 struct dentry
*dentry
;
689 for (i
= start
; i
< eof
; i
++) {
690 name
.name
= files
[i
].name
;
691 name
.len
= strlen(files
[i
].name
);
692 name
.hash
= full_name_hash(name
.name
, name
.len
);
693 dentry
= d_lookup(parent
, &name
);
697 if (dentry
->d_inode
== NULL
)
699 switch (dentry
->d_inode
->i_mode
& S_IFMT
) {
703 __rpc_unlink(dir
, dentry
);
706 __rpc_rmdir(dir
, dentry
);
713 static void rpc_depopulate(struct dentry
*parent
,
714 const struct rpc_filelist
*files
,
717 struct inode
*dir
= parent
->d_inode
;
719 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_CHILD
);
720 __rpc_depopulate(parent
, files
, start
, eof
);
721 mutex_unlock(&dir
->i_mutex
);
724 static int rpc_populate(struct dentry
*parent
,
725 const struct rpc_filelist
*files
,
729 struct inode
*dir
= parent
->d_inode
;
730 struct dentry
*dentry
;
733 mutex_lock(&dir
->i_mutex
);
734 for (i
= start
; i
< eof
; i
++) {
737 q
.name
= files
[i
].name
;
738 q
.len
= strlen(files
[i
].name
);
739 q
.hash
= full_name_hash(q
.name
, q
.len
);
740 dentry
= __rpc_lookup_create_exclusive(parent
, &q
);
741 err
= PTR_ERR(dentry
);
744 switch (files
[i
].mode
& S_IFMT
) {
748 err
= __rpc_create(dir
, dentry
,
754 err
= __rpc_mkdir(dir
, dentry
,
762 mutex_unlock(&dir
->i_mutex
);
765 __rpc_depopulate(parent
, files
, start
, eof
);
766 mutex_unlock(&dir
->i_mutex
);
767 printk(KERN_WARNING
"%s: %s failed to populate directory %s\n",
768 __FILE__
, __func__
, parent
->d_name
.name
);
772 static struct dentry
*rpc_mkdir_populate(struct dentry
*parent
,
773 struct qstr
*name
, umode_t mode
, void *private,
774 int (*populate
)(struct dentry
*, void *), void *args_populate
)
776 struct dentry
*dentry
;
777 struct inode
*dir
= parent
->d_inode
;
780 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
781 dentry
= __rpc_lookup_create_exclusive(parent
, name
);
784 error
= __rpc_mkdir(dir
, dentry
, mode
, NULL
, private);
787 if (populate
!= NULL
) {
788 error
= populate(dentry
, args_populate
);
793 mutex_unlock(&dir
->i_mutex
);
796 __rpc_rmdir(dir
, dentry
);
798 dentry
= ERR_PTR(error
);
802 static int rpc_rmdir_depopulate(struct dentry
*dentry
,
803 void (*depopulate
)(struct dentry
*))
805 struct dentry
*parent
;
809 parent
= dget_parent(dentry
);
810 dir
= parent
->d_inode
;
811 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
812 if (depopulate
!= NULL
)
814 error
= __rpc_rmdir(dir
, dentry
);
815 mutex_unlock(&dir
->i_mutex
);
821 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
822 * @parent: dentry of directory to create new "pipe" in
823 * @name: name of pipe
824 * @private: private data to associate with the pipe, for the caller's use
825 * @pipe: &rpc_pipe containing input parameters
827 * Data is made available for userspace to read by calls to
828 * rpc_queue_upcall(). The actual reads will result in calls to
829 * @ops->upcall, which will be called with the file pointer,
830 * message, and userspace buffer to copy to.
832 * Writes can come at any time, and do not necessarily have to be
833 * responses to upcalls. They will result in calls to @msg->downcall.
835 * The @private argument passed here will be available to all these methods
836 * from the file pointer, via RPC_I(file_inode(file))->private.
838 struct dentry
*rpc_mkpipe_dentry(struct dentry
*parent
, const char *name
,
839 void *private, struct rpc_pipe
*pipe
)
841 struct dentry
*dentry
;
842 struct inode
*dir
= parent
->d_inode
;
843 umode_t umode
= S_IFIFO
| S_IRUSR
| S_IWUSR
;
847 if (pipe
->ops
->upcall
== NULL
)
849 if (pipe
->ops
->downcall
== NULL
)
853 q
.len
= strlen(name
);
854 q
.hash
= full_name_hash(q
.name
, q
.len
),
856 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
857 dentry
= __rpc_lookup_create_exclusive(parent
, &q
);
860 err
= __rpc_mkpipe_dentry(dir
, dentry
, umode
, &rpc_pipe_fops
,
865 mutex_unlock(&dir
->i_mutex
);
868 dentry
= ERR_PTR(err
);
869 printk(KERN_WARNING
"%s: %s() failed to create pipe %s/%s (errno = %d)\n",
870 __FILE__
, __func__
, parent
->d_name
.name
, name
,
874 EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry
);
877 * rpc_unlink - remove a pipe
878 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
880 * After this call, lookups will no longer find the pipe, and any
881 * attempts to read or write using preexisting opens of the pipe will
885 rpc_unlink(struct dentry
*dentry
)
887 struct dentry
*parent
;
891 parent
= dget_parent(dentry
);
892 dir
= parent
->d_inode
;
893 mutex_lock_nested(&dir
->i_mutex
, I_MUTEX_PARENT
);
894 error
= __rpc_rmpipe(dir
, dentry
);
895 mutex_unlock(&dir
->i_mutex
);
899 EXPORT_SYMBOL_GPL(rpc_unlink
);
906 static const struct rpc_filelist authfiles
[] = {
909 .i_fop
= &rpc_info_operations
,
910 .mode
= S_IFREG
| S_IRUSR
,
914 static int rpc_clntdir_populate(struct dentry
*dentry
, void *private)
916 return rpc_populate(dentry
,
917 authfiles
, RPCAUTH_info
, RPCAUTH_EOF
,
921 static void rpc_clntdir_depopulate(struct dentry
*dentry
)
923 rpc_depopulate(dentry
, authfiles
, RPCAUTH_info
, RPCAUTH_EOF
);
927 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
928 * @dentry: dentry from the rpc_pipefs root to the new directory
929 * @name: &struct qstr for the name
930 * @rpc_client: rpc client to associate with this directory
932 * This creates a directory at the given @path associated with
933 * @rpc_clnt, which will contain a file named "info" with some basic
934 * information about the client, together with any "pipes" that may
935 * later be created using rpc_mkpipe().
937 struct dentry
*rpc_create_client_dir(struct dentry
*dentry
,
939 struct rpc_clnt
*rpc_client
)
941 return rpc_mkdir_populate(dentry
, name
, S_IRUGO
| S_IXUGO
, NULL
,
942 rpc_clntdir_populate
, rpc_client
);
946 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
947 * @dentry: dentry for the pipe
949 int rpc_remove_client_dir(struct dentry
*dentry
)
951 return rpc_rmdir_depopulate(dentry
, rpc_clntdir_depopulate
);
954 static const struct rpc_filelist cache_pipefs_files
[3] = {
957 .i_fop
= &cache_file_operations_pipefs
,
958 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
962 .i_fop
= &content_file_operations_pipefs
,
963 .mode
= S_IFREG
|S_IRUSR
,
967 .i_fop
= &cache_flush_operations_pipefs
,
968 .mode
= S_IFREG
|S_IRUSR
|S_IWUSR
,
972 static int rpc_cachedir_populate(struct dentry
*dentry
, void *private)
974 return rpc_populate(dentry
,
975 cache_pipefs_files
, 0, 3,
979 static void rpc_cachedir_depopulate(struct dentry
*dentry
)
981 rpc_depopulate(dentry
, cache_pipefs_files
, 0, 3);
984 struct dentry
*rpc_create_cache_dir(struct dentry
*parent
, struct qstr
*name
,
985 umode_t umode
, struct cache_detail
*cd
)
987 return rpc_mkdir_populate(parent
, name
, umode
, NULL
,
988 rpc_cachedir_populate
, cd
);
991 void rpc_remove_cache_dir(struct dentry
*dentry
)
993 rpc_rmdir_depopulate(dentry
, rpc_cachedir_depopulate
);
997 * populate the filesystem
999 static const struct super_operations s_ops
= {
1000 .alloc_inode
= rpc_alloc_inode
,
1001 .destroy_inode
= rpc_destroy_inode
,
1002 .statfs
= simple_statfs
,
1005 #define RPCAUTH_GSSMAGIC 0x67596969
1008 * We have a single directory with 1 node in it.
1022 static const struct rpc_filelist files
[] = {
1025 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1029 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1033 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1035 [RPCAUTH_portmap
] = {
1037 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1041 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1043 [RPCAUTH_nfsd4_cb
] = {
1045 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1049 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1053 .mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
,
1058 * This call can be used only in RPC pipefs mount notification hooks.
1060 struct dentry
*rpc_d_lookup_sb(const struct super_block
*sb
,
1061 const unsigned char *dir_name
)
1063 struct qstr dir
= QSTR_INIT(dir_name
, strlen(dir_name
));
1065 dir
.hash
= full_name_hash(dir
.name
, dir
.len
);
1066 return d_lookup(sb
->s_root
, &dir
);
1068 EXPORT_SYMBOL_GPL(rpc_d_lookup_sb
);
1070 void rpc_pipefs_init_net(struct net
*net
)
1072 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1074 mutex_init(&sn
->pipefs_sb_lock
);
1075 sn
->gssd_running
= 1;
1076 sn
->pipe_version
= -1;
1080 * This call will be used for per network namespace operations calls.
1081 * Note: Function will be returned with pipefs_sb_lock taken if superblock was
1082 * found. This lock have to be released by rpc_put_sb_net() when all operations
1083 * will be completed.
1085 struct super_block
*rpc_get_sb_net(const struct net
*net
)
1087 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1089 mutex_lock(&sn
->pipefs_sb_lock
);
1091 return sn
->pipefs_sb
;
1092 mutex_unlock(&sn
->pipefs_sb_lock
);
1095 EXPORT_SYMBOL_GPL(rpc_get_sb_net
);
1097 void rpc_put_sb_net(const struct net
*net
)
1099 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1101 WARN_ON(sn
->pipefs_sb
== NULL
);
1102 mutex_unlock(&sn
->pipefs_sb_lock
);
1104 EXPORT_SYMBOL_GPL(rpc_put_sb_net
);
1107 rpc_fill_super(struct super_block
*sb
, void *data
, int silent
)
1109 struct inode
*inode
;
1110 struct dentry
*root
;
1111 struct net
*net
= data
;
1112 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1115 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
1116 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
1117 sb
->s_magic
= RPCAUTH_GSSMAGIC
;
1119 sb
->s_time_gran
= 1;
1121 inode
= rpc_get_inode(sb
, S_IFDIR
| S_IRUGO
| S_IXUGO
);
1122 sb
->s_root
= root
= d_make_root(inode
);
1125 if (rpc_populate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
, NULL
))
1127 dprintk("RPC: sending pipefs MOUNT notification for net %p%s\n",
1128 net
, NET_NAME(net
));
1130 err
= blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1134 goto err_depopulate
;
1135 sb
->s_fs_info
= get_net(net
);
1139 blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1142 sn
->pipefs_sb
= NULL
;
1143 __rpc_depopulate(root
, files
, RPCAUTH_lockd
, RPCAUTH_RootEOF
);
1147 static struct dentry
*
1148 rpc_mount(struct file_system_type
*fs_type
,
1149 int flags
, const char *dev_name
, void *data
)
1151 return mount_ns(fs_type
, flags
, current
->nsproxy
->net_ns
, rpc_fill_super
);
1154 static void rpc_kill_sb(struct super_block
*sb
)
1156 struct net
*net
= sb
->s_fs_info
;
1157 struct sunrpc_net
*sn
= net_generic(net
, sunrpc_net_id
);
1159 mutex_lock(&sn
->pipefs_sb_lock
);
1160 if (sn
->pipefs_sb
!= sb
) {
1161 mutex_unlock(&sn
->pipefs_sb_lock
);
1164 sn
->pipefs_sb
= NULL
;
1165 mutex_unlock(&sn
->pipefs_sb_lock
);
1166 dprintk("RPC: sending pipefs UMOUNT notification for net %p%s\n",
1167 net
, NET_NAME(net
));
1168 blocking_notifier_call_chain(&rpc_pipefs_notifier_list
,
1173 kill_litter_super(sb
);
1176 static struct file_system_type rpc_pipe_fs_type
= {
1177 .owner
= THIS_MODULE
,
1178 .name
= "rpc_pipefs",
1180 .kill_sb
= rpc_kill_sb
,
1182 MODULE_ALIAS_FS("rpc_pipefs");
1183 MODULE_ALIAS("rpc_pipefs");
1186 init_once(void *foo
)
1188 struct rpc_inode
*rpci
= (struct rpc_inode
*) foo
;
1190 inode_init_once(&rpci
->vfs_inode
);
1191 rpci
->private = NULL
;
1193 init_waitqueue_head(&rpci
->waitq
);
1196 int register_rpc_pipefs(void)
1200 rpc_inode_cachep
= kmem_cache_create("rpc_inode_cache",
1201 sizeof(struct rpc_inode
),
1202 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
1205 if (!rpc_inode_cachep
)
1207 err
= rpc_clients_notifier_register();
1210 err
= register_filesystem(&rpc_pipe_fs_type
);
1216 rpc_clients_notifier_unregister();
1218 kmem_cache_destroy(rpc_inode_cachep
);
1222 void unregister_rpc_pipefs(void)
1224 rpc_clients_notifier_unregister();
1225 kmem_cache_destroy(rpc_inode_cachep
);
1226 unregister_filesystem(&rpc_pipe_fs_type
);