6dd8b96e8df75e7c75c9571c017b22e15507d513
[linux-3.10.git] / net / sunrpc / rpc_pipe.c
1 /*
2  * net/sunrpc/rpc_pipe.c
3  *
4  * Userland/kernel interface for rpcauth_gss.
5  * Code shamelessly plagiarized from fs/nfsd/nfsctl.c
6  * and fs/sysfs/inode.c
7  *
8  * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
9  *
10  */
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
20 #include <asm/ioctls.h>
21 #include <linux/fs.h>
22 #include <linux/poll.h>
23 #include <linux/wait.h>
24 #include <linux/seq_file.h>
25
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>
32
33 #include "netns.h"
34 #include "sunrpc.h"
35
36 #define RPCDBG_FACILITY RPCDBG_DEBUG
37
38 #define NET_NAME(net)   ((net == &init_net) ? " (init_net)" : "")
39
40 static struct vfsmount *rpc_mnt __read_mostly;
41 static int rpc_mount_count;
42
43 static struct file_system_type rpc_pipe_fs_type;
44
45
46 static struct kmem_cache *rpc_inode_cachep __read_mostly;
47
48 #define RPC_UPCALL_TIMEOUT (30*HZ)
49
50 static BLOCKING_NOTIFIER_HEAD(rpc_pipefs_notifier_list);
51
52 int rpc_pipefs_notifier_register(struct notifier_block *nb)
53 {
54         return blocking_notifier_chain_cond_register(&rpc_pipefs_notifier_list, nb);
55 }
56 EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_register);
57
58 void rpc_pipefs_notifier_unregister(struct notifier_block *nb)
59 {
60         blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list, nb);
61 }
62 EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_unregister);
63
64 static void rpc_purge_list(struct rpc_pipe *pipe, struct list_head *head,
65                 void (*destroy_msg)(struct rpc_pipe_msg *), int err)
66 {
67         struct rpc_pipe_msg *msg;
68
69         if (list_empty(head))
70                 return;
71         do {
72                 msg = list_entry(head->next, struct rpc_pipe_msg, list);
73                 list_del_init(&msg->list);
74                 msg->errno = err;
75                 destroy_msg(msg);
76         } while (!list_empty(head));
77         wake_up(&pipe->waitq);
78 }
79
80 static void
81 rpc_timeout_upcall_queue(struct work_struct *work)
82 {
83         LIST_HEAD(free_list);
84         struct rpc_pipe *pipe =
85                 container_of(work, struct rpc_pipe, queue_timeout.work);
86         void (*destroy_msg)(struct rpc_pipe_msg *);
87
88         spin_lock(&pipe->lock);
89         if (pipe->ops == NULL) {
90                 spin_unlock(&pipe->lock);
91                 return;
92         }
93         destroy_msg = pipe->ops->destroy_msg;
94         if (pipe->nreaders == 0) {
95                 list_splice_init(&pipe->pipe, &free_list);
96                 pipe->pipelen = 0;
97         }
98         spin_unlock(&pipe->lock);
99         rpc_purge_list(pipe, &free_list, destroy_msg, -ETIMEDOUT);
100 }
101
102 ssize_t rpc_pipe_generic_upcall(struct file *filp, struct rpc_pipe_msg *msg,
103                                 char __user *dst, size_t buflen)
104 {
105         char *data = (char *)msg->data + msg->copied;
106         size_t mlen = min(msg->len - msg->copied, buflen);
107         unsigned long left;
108
109         left = copy_to_user(dst, data, mlen);
110         if (left == mlen) {
111                 msg->errno = -EFAULT;
112                 return -EFAULT;
113         }
114
115         mlen -= left;
116         msg->copied += mlen;
117         msg->errno = 0;
118         return mlen;
119 }
120 EXPORT_SYMBOL_GPL(rpc_pipe_generic_upcall);
121
122 /**
123  * rpc_queue_upcall - queue an upcall message to userspace
124  * @inode: inode of upcall pipe on which to queue given message
125  * @msg: message to queue
126  *
127  * Call with an @inode created by rpc_mkpipe() to queue an upcall.
128  * A userspace process may then later read the upcall by performing a
129  * read on an open file for this inode.  It is up to the caller to
130  * initialize the fields of @msg (other than @msg->list) appropriately.
131  */
132 int
133 rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg)
134 {
135         int res = -EPIPE;
136
137         spin_lock(&pipe->lock);
138         if (pipe->ops == NULL)
139                 goto out;
140         if (pipe->nreaders) {
141                 list_add_tail(&msg->list, &pipe->pipe);
142                 pipe->pipelen += msg->len;
143                 res = 0;
144         } else if (pipe->flags & RPC_PIPE_WAIT_FOR_OPEN) {
145                 if (list_empty(&pipe->pipe))
146                         queue_delayed_work(rpciod_workqueue,
147                                         &pipe->queue_timeout,
148                                         RPC_UPCALL_TIMEOUT);
149                 list_add_tail(&msg->list, &pipe->pipe);
150                 pipe->pipelen += msg->len;
151                 res = 0;
152         }
153 out:
154         spin_unlock(&pipe->lock);
155         wake_up(&pipe->waitq);
156         return res;
157 }
158 EXPORT_SYMBOL_GPL(rpc_queue_upcall);
159
160 static inline void
161 rpc_inode_setowner(struct inode *inode, void *private)
162 {
163         RPC_I(inode)->private = private;
164 }
165
166 static void
167 rpc_close_pipes(struct inode *inode)
168 {
169         struct rpc_pipe *pipe = RPC_I(inode)->pipe;
170         const struct rpc_pipe_ops *ops;
171         int need_release;
172
173         mutex_lock(&inode->i_mutex);
174         ops = pipe->ops;
175         if (ops != NULL) {
176                 LIST_HEAD(free_list);
177                 spin_lock(&pipe->lock);
178                 need_release = pipe->nreaders != 0 || pipe->nwriters != 0;
179                 pipe->nreaders = 0;
180                 list_splice_init(&pipe->in_upcall, &free_list);
181                 list_splice_init(&pipe->pipe, &free_list);
182                 pipe->pipelen = 0;
183                 pipe->ops = NULL;
184                 spin_unlock(&pipe->lock);
185                 rpc_purge_list(pipe, &free_list, ops->destroy_msg, -EPIPE);
186                 pipe->nwriters = 0;
187                 if (need_release && ops->release_pipe)
188                         ops->release_pipe(inode);
189                 cancel_delayed_work_sync(&pipe->queue_timeout);
190         }
191         rpc_inode_setowner(inode, NULL);
192         mutex_unlock(&inode->i_mutex);
193 }
194
195 static struct inode *
196 rpc_alloc_inode(struct super_block *sb)
197 {
198         struct rpc_inode *rpci;
199         rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
200         if (!rpci)
201                 return NULL;
202         return &rpci->vfs_inode;
203 }
204
205 static void
206 rpc_i_callback(struct rcu_head *head)
207 {
208         struct inode *inode = container_of(head, struct inode, i_rcu);
209         kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
210 }
211
212 static void
213 rpc_destroy_inode(struct inode *inode)
214 {
215         call_rcu(&inode->i_rcu, rpc_i_callback);
216 }
217
218 static int
219 rpc_pipe_open(struct inode *inode, struct file *filp)
220 {
221         struct rpc_pipe *pipe = RPC_I(inode)->pipe;
222         int first_open;
223         int res = -ENXIO;
224
225         mutex_lock(&inode->i_mutex);
226         if (pipe->ops == NULL)
227                 goto out;
228         first_open = pipe->nreaders == 0 && pipe->nwriters == 0;
229         if (first_open && pipe->ops->open_pipe) {
230                 res = pipe->ops->open_pipe(inode);
231                 if (res)
232                         goto out;
233         }
234         if (filp->f_mode & FMODE_READ)
235                 pipe->nreaders++;
236         if (filp->f_mode & FMODE_WRITE)
237                 pipe->nwriters++;
238         res = 0;
239 out:
240         mutex_unlock(&inode->i_mutex);
241         return res;
242 }
243
244 static int
245 rpc_pipe_release(struct inode *inode, struct file *filp)
246 {
247         struct rpc_pipe *pipe = RPC_I(inode)->pipe;
248         struct rpc_pipe_msg *msg;
249         int last_close;
250
251         mutex_lock(&inode->i_mutex);
252         if (pipe->ops == NULL)
253                 goto out;
254         msg = filp->private_data;
255         if (msg != NULL) {
256                 spin_lock(&pipe->lock);
257                 msg->errno = -EAGAIN;
258                 list_del_init(&msg->list);
259                 spin_unlock(&pipe->lock);
260                 pipe->ops->destroy_msg(msg);
261         }
262         if (filp->f_mode & FMODE_WRITE)
263                 pipe->nwriters --;
264         if (filp->f_mode & FMODE_READ) {
265                 pipe->nreaders --;
266                 if (pipe->nreaders == 0) {
267                         LIST_HEAD(free_list);
268                         spin_lock(&pipe->lock);
269                         list_splice_init(&pipe->pipe, &free_list);
270                         pipe->pipelen = 0;
271                         spin_unlock(&pipe->lock);
272                         rpc_purge_list(pipe, &free_list,
273                                         pipe->ops->destroy_msg, -EAGAIN);
274                 }
275         }
276         last_close = pipe->nwriters == 0 && pipe->nreaders == 0;
277         if (last_close && pipe->ops->release_pipe)
278                 pipe->ops->release_pipe(inode);
279 out:
280         mutex_unlock(&inode->i_mutex);
281         return 0;
282 }
283
284 static ssize_t
285 rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
286 {
287         struct inode *inode = filp->f_path.dentry->d_inode;
288         struct rpc_pipe *pipe = RPC_I(inode)->pipe;
289         struct rpc_pipe_msg *msg;
290         int res = 0;
291
292         mutex_lock(&inode->i_mutex);
293         if (pipe->ops == NULL) {
294                 res = -EPIPE;
295                 goto out_unlock;
296         }
297         msg = filp->private_data;
298         if (msg == NULL) {
299                 spin_lock(&pipe->lock);
300                 if (!list_empty(&pipe->pipe)) {
301                         msg = list_entry(pipe->pipe.next,
302                                         struct rpc_pipe_msg,
303                                         list);
304                         list_move(&msg->list, &pipe->in_upcall);
305                         pipe->pipelen -= msg->len;
306                         filp->private_data = msg;
307                         msg->copied = 0;
308                 }
309                 spin_unlock(&pipe->lock);
310                 if (msg == NULL)
311                         goto out_unlock;
312         }
313         /* NOTE: it is up to the callback to update msg->copied */
314         res = pipe->ops->upcall(filp, msg, buf, len);
315         if (res < 0 || msg->len == msg->copied) {
316                 filp->private_data = NULL;
317                 spin_lock(&pipe->lock);
318                 list_del_init(&msg->list);
319                 spin_unlock(&pipe->lock);
320                 pipe->ops->destroy_msg(msg);
321         }
322 out_unlock:
323         mutex_unlock(&inode->i_mutex);
324         return res;
325 }
326
327 static ssize_t
328 rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
329 {
330         struct inode *inode = filp->f_path.dentry->d_inode;
331         struct rpc_pipe *pipe = RPC_I(inode)->pipe;
332         int res;
333
334         mutex_lock(&inode->i_mutex);
335         res = -EPIPE;
336         if (pipe->ops != NULL)
337                 res = pipe->ops->downcall(filp, buf, len);
338         mutex_unlock(&inode->i_mutex);
339         return res;
340 }
341
342 static unsigned int
343 rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
344 {
345         struct rpc_pipe *pipe = RPC_I(filp->f_path.dentry->d_inode)->pipe;
346         unsigned int mask = 0;
347
348         poll_wait(filp, &pipe->waitq, wait);
349
350         mask = POLLOUT | POLLWRNORM;
351         if (pipe->ops == NULL)
352                 mask |= POLLERR | POLLHUP;
353         if (filp->private_data || !list_empty(&pipe->pipe))
354                 mask |= POLLIN | POLLRDNORM;
355         return mask;
356 }
357
358 static long
359 rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
360 {
361         struct inode *inode = filp->f_path.dentry->d_inode;
362         struct rpc_pipe *pipe = RPC_I(inode)->pipe;
363         int len;
364
365         switch (cmd) {
366         case FIONREAD:
367                 spin_lock(&pipe->lock);
368                 if (pipe->ops == NULL) {
369                         spin_unlock(&pipe->lock);
370                         return -EPIPE;
371                 }
372                 len = pipe->pipelen;
373                 if (filp->private_data) {
374                         struct rpc_pipe_msg *msg;
375                         msg = filp->private_data;
376                         len += msg->len - msg->copied;
377                 }
378                 spin_unlock(&pipe->lock);
379                 return put_user(len, (int __user *)arg);
380         default:
381                 return -EINVAL;
382         }
383 }
384
385 static const struct file_operations rpc_pipe_fops = {
386         .owner          = THIS_MODULE,
387         .llseek         = no_llseek,
388         .read           = rpc_pipe_read,
389         .write          = rpc_pipe_write,
390         .poll           = rpc_pipe_poll,
391         .unlocked_ioctl = rpc_pipe_ioctl,
392         .open           = rpc_pipe_open,
393         .release        = rpc_pipe_release,
394 };
395
396 static int
397 rpc_show_info(struct seq_file *m, void *v)
398 {
399         struct rpc_clnt *clnt = m->private;
400
401         seq_printf(m, "RPC server: %s\n", clnt->cl_server);
402         seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
403                         clnt->cl_prog, clnt->cl_vers);
404         seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
405         seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
406         seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
407         return 0;
408 }
409
410 static int
411 rpc_info_open(struct inode *inode, struct file *file)
412 {
413         struct rpc_clnt *clnt = NULL;
414         int ret = single_open(file, rpc_show_info, NULL);
415
416         if (!ret) {
417                 struct seq_file *m = file->private_data;
418
419                 spin_lock(&file->f_path.dentry->d_lock);
420                 if (!d_unhashed(file->f_path.dentry))
421                         clnt = RPC_I(inode)->private;
422                 if (clnt != NULL && atomic_inc_not_zero(&clnt->cl_count)) {
423                         spin_unlock(&file->f_path.dentry->d_lock);
424                         m->private = clnt;
425                 } else {
426                         spin_unlock(&file->f_path.dentry->d_lock);
427                         single_release(inode, file);
428                         ret = -EINVAL;
429                 }
430         }
431         return ret;
432 }
433
434 static int
435 rpc_info_release(struct inode *inode, struct file *file)
436 {
437         struct seq_file *m = file->private_data;
438         struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
439
440         if (clnt)
441                 rpc_release_client(clnt);
442         return single_release(inode, file);
443 }
444
445 static const struct file_operations rpc_info_operations = {
446         .owner          = THIS_MODULE,
447         .open           = rpc_info_open,
448         .read           = seq_read,
449         .llseek         = seq_lseek,
450         .release        = rpc_info_release,
451 };
452
453
454 /*
455  * Description of fs contents.
456  */
457 struct rpc_filelist {
458         const char *name;
459         const struct file_operations *i_fop;
460         umode_t mode;
461 };
462
463 struct vfsmount *rpc_get_mount(void)
464 {
465         int err;
466
467         err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mnt, &rpc_mount_count);
468         if (err != 0)
469                 return ERR_PTR(err);
470         return rpc_mnt;
471 }
472 EXPORT_SYMBOL_GPL(rpc_get_mount);
473
474 void rpc_put_mount(void)
475 {
476         simple_release_fs(&rpc_mnt, &rpc_mount_count);
477 }
478 EXPORT_SYMBOL_GPL(rpc_put_mount);
479
480 static int rpc_delete_dentry(const struct dentry *dentry)
481 {
482         return 1;
483 }
484
485 static const struct dentry_operations rpc_dentry_operations = {
486         .d_delete = rpc_delete_dentry,
487 };
488
489 static struct inode *
490 rpc_get_inode(struct super_block *sb, umode_t mode)
491 {
492         struct inode *inode = new_inode(sb);
493         if (!inode)
494                 return NULL;
495         inode->i_ino = get_next_ino();
496         inode->i_mode = mode;
497         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
498         switch (mode & S_IFMT) {
499         case S_IFDIR:
500                 inode->i_fop = &simple_dir_operations;
501                 inode->i_op = &simple_dir_inode_operations;
502                 inc_nlink(inode);
503         default:
504                 break;
505         }
506         return inode;
507 }
508
509 static int __rpc_create_common(struct inode *dir, struct dentry *dentry,
510                                umode_t mode,
511                                const struct file_operations *i_fop,
512                                void *private)
513 {
514         struct inode *inode;
515
516         d_drop(dentry);
517         inode = rpc_get_inode(dir->i_sb, mode);
518         if (!inode)
519                 goto out_err;
520         inode->i_ino = iunique(dir->i_sb, 100);
521         if (i_fop)
522                 inode->i_fop = i_fop;
523         if (private)
524                 rpc_inode_setowner(inode, private);
525         d_add(dentry, inode);
526         return 0;
527 out_err:
528         printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
529                         __FILE__, __func__, dentry->d_name.name);
530         dput(dentry);
531         return -ENOMEM;
532 }
533
534 static int __rpc_create(struct inode *dir, struct dentry *dentry,
535                         umode_t mode,
536                         const struct file_operations *i_fop,
537                         void *private)
538 {
539         int err;
540
541         err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private);
542         if (err)
543                 return err;
544         fsnotify_create(dir, dentry);
545         return 0;
546 }
547
548 static int __rpc_mkdir(struct inode *dir, struct dentry *dentry,
549                        umode_t mode,
550                        const struct file_operations *i_fop,
551                        void *private)
552 {
553         int err;
554
555         err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private);
556         if (err)
557                 return err;
558         inc_nlink(dir);
559         fsnotify_mkdir(dir, dentry);
560         return 0;
561 }
562
563 static void
564 init_pipe(struct rpc_pipe *pipe)
565 {
566         pipe->nreaders = 0;
567         pipe->nwriters = 0;
568         INIT_LIST_HEAD(&pipe->in_upcall);
569         INIT_LIST_HEAD(&pipe->in_downcall);
570         INIT_LIST_HEAD(&pipe->pipe);
571         pipe->pipelen = 0;
572         init_waitqueue_head(&pipe->waitq);
573         INIT_DELAYED_WORK(&pipe->queue_timeout,
574                             rpc_timeout_upcall_queue);
575         pipe->ops = NULL;
576         spin_lock_init(&pipe->lock);
577         pipe->dentry = NULL;
578 }
579
580 void rpc_destroy_pipe_data(struct rpc_pipe *pipe)
581 {
582         kfree(pipe);
583 }
584 EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data);
585
586 struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags)
587 {
588         struct rpc_pipe *pipe;
589
590         pipe = kzalloc(sizeof(struct rpc_pipe), GFP_KERNEL);
591         if (!pipe)
592                 return ERR_PTR(-ENOMEM);
593         init_pipe(pipe);
594         pipe->ops = ops;
595         pipe->flags = flags;
596         return pipe;
597 }
598 EXPORT_SYMBOL_GPL(rpc_mkpipe_data);
599
600 static int __rpc_mkpipe_dentry(struct inode *dir, struct dentry *dentry,
601                                umode_t mode,
602                                const struct file_operations *i_fop,
603                                void *private,
604                                struct rpc_pipe *pipe)
605 {
606         struct rpc_inode *rpci;
607         int err;
608
609         err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private);
610         if (err)
611                 return err;
612         rpci = RPC_I(dentry->d_inode);
613         rpci->private = private;
614         rpci->pipe = pipe;
615         fsnotify_create(dir, dentry);
616         return 0;
617 }
618
619 static int __rpc_rmdir(struct inode *dir, struct dentry *dentry)
620 {
621         int ret;
622
623         dget(dentry);
624         ret = simple_rmdir(dir, dentry);
625         d_delete(dentry);
626         dput(dentry);
627         return ret;
628 }
629
630 static int __rpc_unlink(struct inode *dir, struct dentry *dentry)
631 {
632         int ret;
633
634         dget(dentry);
635         ret = simple_unlink(dir, dentry);
636         d_delete(dentry);
637         dput(dentry);
638         return ret;
639 }
640
641 static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry)
642 {
643         struct inode *inode = dentry->d_inode;
644
645         rpc_close_pipes(inode);
646         return __rpc_unlink(dir, dentry);
647 }
648
649 static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent,
650                                           struct qstr *name)
651 {
652         struct dentry *dentry;
653
654         dentry = d_lookup(parent, name);
655         if (!dentry) {
656                 dentry = d_alloc(parent, name);
657                 if (!dentry)
658                         return ERR_PTR(-ENOMEM);
659         }
660         if (dentry->d_inode == NULL) {
661                 d_set_d_op(dentry, &rpc_dentry_operations);
662                 return dentry;
663         }
664         dput(dentry);
665         return ERR_PTR(-EEXIST);
666 }
667
668 /*
669  * FIXME: This probably has races.
670  */
671 static void __rpc_depopulate(struct dentry *parent,
672                              const struct rpc_filelist *files,
673                              int start, int eof)
674 {
675         struct inode *dir = parent->d_inode;
676         struct dentry *dentry;
677         struct qstr name;
678         int i;
679
680         for (i = start; i < eof; i++) {
681                 name.name = files[i].name;
682                 name.len = strlen(files[i].name);
683                 name.hash = full_name_hash(name.name, name.len);
684                 dentry = d_lookup(parent, &name);
685
686                 if (dentry == NULL)
687                         continue;
688                 if (dentry->d_inode == NULL)
689                         goto next;
690                 switch (dentry->d_inode->i_mode & S_IFMT) {
691                         default:
692                                 BUG();
693                         case S_IFREG:
694                                 __rpc_unlink(dir, dentry);
695                                 break;
696                         case S_IFDIR:
697                                 __rpc_rmdir(dir, dentry);
698                 }
699 next:
700                 dput(dentry);
701         }
702 }
703
704 static void rpc_depopulate(struct dentry *parent,
705                            const struct rpc_filelist *files,
706                            int start, int eof)
707 {
708         struct inode *dir = parent->d_inode;
709
710         mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
711         __rpc_depopulate(parent, files, start, eof);
712         mutex_unlock(&dir->i_mutex);
713 }
714
715 static int rpc_populate(struct dentry *parent,
716                         const struct rpc_filelist *files,
717                         int start, int eof,
718                         void *private)
719 {
720         struct inode *dir = parent->d_inode;
721         struct dentry *dentry;
722         int i, err;
723
724         mutex_lock(&dir->i_mutex);
725         for (i = start; i < eof; i++) {
726                 struct qstr q;
727
728                 q.name = files[i].name;
729                 q.len = strlen(files[i].name);
730                 q.hash = full_name_hash(q.name, q.len);
731                 dentry = __rpc_lookup_create_exclusive(parent, &q);
732                 err = PTR_ERR(dentry);
733                 if (IS_ERR(dentry))
734                         goto out_bad;
735                 switch (files[i].mode & S_IFMT) {
736                         default:
737                                 BUG();
738                         case S_IFREG:
739                                 err = __rpc_create(dir, dentry,
740                                                 files[i].mode,
741                                                 files[i].i_fop,
742                                                 private);
743                                 break;
744                         case S_IFDIR:
745                                 err = __rpc_mkdir(dir, dentry,
746                                                 files[i].mode,
747                                                 NULL,
748                                                 private);
749                 }
750                 if (err != 0)
751                         goto out_bad;
752         }
753         mutex_unlock(&dir->i_mutex);
754         return 0;
755 out_bad:
756         __rpc_depopulate(parent, files, start, eof);
757         mutex_unlock(&dir->i_mutex);
758         printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
759                         __FILE__, __func__, parent->d_name.name);
760         return err;
761 }
762
763 static struct dentry *rpc_mkdir_populate(struct dentry *parent,
764                 struct qstr *name, umode_t mode, void *private,
765                 int (*populate)(struct dentry *, void *), void *args_populate)
766 {
767         struct dentry *dentry;
768         struct inode *dir = parent->d_inode;
769         int error;
770
771         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
772         dentry = __rpc_lookup_create_exclusive(parent, name);
773         if (IS_ERR(dentry))
774                 goto out;
775         error = __rpc_mkdir(dir, dentry, mode, NULL, private);
776         if (error != 0)
777                 goto out_err;
778         if (populate != NULL) {
779                 error = populate(dentry, args_populate);
780                 if (error)
781                         goto err_rmdir;
782         }
783 out:
784         mutex_unlock(&dir->i_mutex);
785         return dentry;
786 err_rmdir:
787         __rpc_rmdir(dir, dentry);
788 out_err:
789         dentry = ERR_PTR(error);
790         goto out;
791 }
792
793 static int rpc_rmdir_depopulate(struct dentry *dentry,
794                 void (*depopulate)(struct dentry *))
795 {
796         struct dentry *parent;
797         struct inode *dir;
798         int error;
799
800         parent = dget_parent(dentry);
801         dir = parent->d_inode;
802         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
803         if (depopulate != NULL)
804                 depopulate(dentry);
805         error = __rpc_rmdir(dir, dentry);
806         mutex_unlock(&dir->i_mutex);
807         dput(parent);
808         return error;
809 }
810
811 /**
812  * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
813  * @parent: dentry of directory to create new "pipe" in
814  * @name: name of pipe
815  * @private: private data to associate with the pipe, for the caller's use
816  * @ops: operations defining the behavior of the pipe: upcall, downcall,
817  *      release_pipe, open_pipe, and destroy_msg.
818  * @flags: rpc_pipe flags
819  *
820  * Data is made available for userspace to read by calls to
821  * rpc_queue_upcall().  The actual reads will result in calls to
822  * @ops->upcall, which will be called with the file pointer,
823  * message, and userspace buffer to copy to.
824  *
825  * Writes can come at any time, and do not necessarily have to be
826  * responses to upcalls.  They will result in calls to @msg->downcall.
827  *
828  * The @private argument passed here will be available to all these methods
829  * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
830  */
831 struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name,
832                                  void *private, struct rpc_pipe *pipe)
833 {
834         struct dentry *dentry;
835         struct inode *dir = parent->d_inode;
836         umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR;
837         struct qstr q;
838         int err;
839
840         if (pipe->ops->upcall == NULL)
841                 umode &= ~S_IRUGO;
842         if (pipe->ops->downcall == NULL)
843                 umode &= ~S_IWUGO;
844
845         q.name = name;
846         q.len = strlen(name);
847         q.hash = full_name_hash(q.name, q.len),
848
849         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
850         dentry = __rpc_lookup_create_exclusive(parent, &q);
851         if (IS_ERR(dentry))
852                 goto out;
853         err = __rpc_mkpipe_dentry(dir, dentry, umode, &rpc_pipe_fops,
854                                   private, pipe);
855         if (err)
856                 goto out_err;
857 out:
858         mutex_unlock(&dir->i_mutex);
859         return dentry;
860 out_err:
861         dentry = ERR_PTR(err);
862         printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
863                         __FILE__, __func__, parent->d_name.name, name,
864                         err);
865         goto out;
866 }
867 EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry);
868
869 /**
870  * rpc_unlink - remove a pipe
871  * @dentry: dentry for the pipe, as returned from rpc_mkpipe
872  *
873  * After this call, lookups will no longer find the pipe, and any
874  * attempts to read or write using preexisting opens of the pipe will
875  * return -EPIPE.
876  */
877 int
878 rpc_unlink(struct dentry *dentry)
879 {
880         struct dentry *parent;
881         struct inode *dir;
882         int error = 0;
883
884         parent = dget_parent(dentry);
885         dir = parent->d_inode;
886         mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
887         error = __rpc_rmpipe(dir, dentry);
888         mutex_unlock(&dir->i_mutex);
889         dput(parent);
890         return error;
891 }
892 EXPORT_SYMBOL_GPL(rpc_unlink);
893
894 enum {
895         RPCAUTH_info,
896         RPCAUTH_EOF
897 };
898
899 static const struct rpc_filelist authfiles[] = {
900         [RPCAUTH_info] = {
901                 .name = "info",
902                 .i_fop = &rpc_info_operations,
903                 .mode = S_IFREG | S_IRUSR,
904         },
905 };
906
907 static int rpc_clntdir_populate(struct dentry *dentry, void *private)
908 {
909         return rpc_populate(dentry,
910                             authfiles, RPCAUTH_info, RPCAUTH_EOF,
911                             private);
912 }
913
914 static void rpc_clntdir_depopulate(struct dentry *dentry)
915 {
916         rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF);
917 }
918
919 /**
920  * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs
921  * @dentry: dentry from the rpc_pipefs root to the new directory
922  * @name: &struct qstr for the name
923  * @rpc_client: rpc client to associate with this directory
924  *
925  * This creates a directory at the given @path associated with
926  * @rpc_clnt, which will contain a file named "info" with some basic
927  * information about the client, together with any "pipes" that may
928  * later be created using rpc_mkpipe().
929  */
930 struct dentry *rpc_create_client_dir(struct dentry *dentry,
931                                    struct qstr *name,
932                                    struct rpc_clnt *rpc_client)
933 {
934         return rpc_mkdir_populate(dentry, name, S_IRUGO | S_IXUGO, NULL,
935                         rpc_clntdir_populate, rpc_client);
936 }
937
938 /**
939  * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir()
940  * @dentry: directory to remove
941  */
942 int rpc_remove_client_dir(struct dentry *dentry)
943 {
944         return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate);
945 }
946
947 static const struct rpc_filelist cache_pipefs_files[3] = {
948         [0] = {
949                 .name = "channel",
950                 .i_fop = &cache_file_operations_pipefs,
951                 .mode = S_IFREG|S_IRUSR|S_IWUSR,
952         },
953         [1] = {
954                 .name = "content",
955                 .i_fop = &content_file_operations_pipefs,
956                 .mode = S_IFREG|S_IRUSR,
957         },
958         [2] = {
959                 .name = "flush",
960                 .i_fop = &cache_flush_operations_pipefs,
961                 .mode = S_IFREG|S_IRUSR|S_IWUSR,
962         },
963 };
964
965 static int rpc_cachedir_populate(struct dentry *dentry, void *private)
966 {
967         return rpc_populate(dentry,
968                             cache_pipefs_files, 0, 3,
969                             private);
970 }
971
972 static void rpc_cachedir_depopulate(struct dentry *dentry)
973 {
974         rpc_depopulate(dentry, cache_pipefs_files, 0, 3);
975 }
976
977 struct dentry *rpc_create_cache_dir(struct dentry *parent, struct qstr *name,
978                                     umode_t umode, struct cache_detail *cd)
979 {
980         return rpc_mkdir_populate(parent, name, umode, NULL,
981                         rpc_cachedir_populate, cd);
982 }
983
984 void rpc_remove_cache_dir(struct dentry *dentry)
985 {
986         rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate);
987 }
988
989 /*
990  * populate the filesystem
991  */
992 static const struct super_operations s_ops = {
993         .alloc_inode    = rpc_alloc_inode,
994         .destroy_inode  = rpc_destroy_inode,
995         .statfs         = simple_statfs,
996 };
997
998 #define RPCAUTH_GSSMAGIC 0x67596969
999
1000 /*
1001  * We have a single directory with 1 node in it.
1002  */
1003 enum {
1004         RPCAUTH_lockd,
1005         RPCAUTH_mount,
1006         RPCAUTH_nfs,
1007         RPCAUTH_portmap,
1008         RPCAUTH_statd,
1009         RPCAUTH_nfsd4_cb,
1010         RPCAUTH_cache,
1011         RPCAUTH_RootEOF
1012 };
1013
1014 static const struct rpc_filelist files[] = {
1015         [RPCAUTH_lockd] = {
1016                 .name = "lockd",
1017                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1018         },
1019         [RPCAUTH_mount] = {
1020                 .name = "mount",
1021                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1022         },
1023         [RPCAUTH_nfs] = {
1024                 .name = "nfs",
1025                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1026         },
1027         [RPCAUTH_portmap] = {
1028                 .name = "portmap",
1029                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1030         },
1031         [RPCAUTH_statd] = {
1032                 .name = "statd",
1033                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1034         },
1035         [RPCAUTH_nfsd4_cb] = {
1036                 .name = "nfsd4_cb",
1037                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1038         },
1039         [RPCAUTH_cache] = {
1040                 .name = "cache",
1041                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
1042         },
1043 };
1044
1045 /*
1046  * This call can be used only in RPC pipefs mount notification hooks.
1047  */
1048 struct dentry *rpc_d_lookup_sb(const struct super_block *sb,
1049                                const unsigned char *dir_name)
1050 {
1051         struct qstr dir = {
1052                 .name = dir_name,
1053                 .len = strlen(dir_name),
1054                 .hash = full_name_hash(dir_name, strlen(dir_name)),
1055         };
1056
1057         return d_lookup(sb->s_root, &dir);
1058 }
1059 EXPORT_SYMBOL_GPL(rpc_d_lookup_sb);
1060
1061 void rpc_pipefs_init_net(struct net *net)
1062 {
1063         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1064
1065         mutex_init(&sn->pipefs_sb_lock);
1066 }
1067
1068 /*
1069  * This call will be used for per network namespace operations calls.
1070  * Note: Function will be returned with pipefs_sb_lock taken if superblock was
1071  * found. This lock have to be released by rpc_put_sb_net() when all operations
1072  * will be completed.
1073  */
1074 struct super_block *rpc_get_sb_net(const struct net *net)
1075 {
1076         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1077
1078         mutex_lock(&sn->pipefs_sb_lock);
1079         if (sn->pipefs_sb)
1080                 return sn->pipefs_sb;
1081         mutex_unlock(&sn->pipefs_sb_lock);
1082         return NULL;
1083 }
1084 EXPORT_SYMBOL_GPL(rpc_get_sb_net);
1085
1086 void rpc_put_sb_net(const struct net *net)
1087 {
1088         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1089
1090         BUG_ON(sn->pipefs_sb == NULL);
1091         mutex_unlock(&sn->pipefs_sb_lock);
1092 }
1093 EXPORT_SYMBOL_GPL(rpc_put_sb_net);
1094
1095 static int
1096 rpc_fill_super(struct super_block *sb, void *data, int silent)
1097 {
1098         struct inode *inode;
1099         struct dentry *root;
1100         struct net *net = data;
1101         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1102         int err;
1103
1104         sb->s_blocksize = PAGE_CACHE_SIZE;
1105         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
1106         sb->s_magic = RPCAUTH_GSSMAGIC;
1107         sb->s_op = &s_ops;
1108         sb->s_time_gran = 1;
1109
1110         inode = rpc_get_inode(sb, S_IFDIR | 0755);
1111         if (!inode)
1112                 return -ENOMEM;
1113         sb->s_root = root = d_alloc_root(inode);
1114         if (!root) {
1115                 iput(inode);
1116                 return -ENOMEM;
1117         }
1118         if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL))
1119                 return -ENOMEM;
1120         dprintk("RPC:   sending pipefs MOUNT notification for net %p%s\n", net,
1121                                                                 NET_NAME(net));
1122         err = blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1123                                            RPC_PIPEFS_MOUNT,
1124                                            sb);
1125         if (err)
1126                 goto err_depopulate;
1127         sb->s_fs_info = get_net(net);
1128         sn->pipefs_sb = sb;
1129         return 0;
1130
1131 err_depopulate:
1132         blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1133                                            RPC_PIPEFS_UMOUNT,
1134                                            sb);
1135         __rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF);
1136         return err;
1137 }
1138
1139 static struct dentry *
1140 rpc_mount(struct file_system_type *fs_type,
1141                 int flags, const char *dev_name, void *data)
1142 {
1143         return mount_ns(fs_type, flags, current->nsproxy->net_ns, rpc_fill_super);
1144 }
1145
1146 void rpc_kill_sb(struct super_block *sb)
1147 {
1148         struct net *net = sb->s_fs_info;
1149         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
1150
1151         mutex_lock(&sn->pipefs_sb_lock);
1152         sn->pipefs_sb = NULL;
1153         mutex_unlock(&sn->pipefs_sb_lock);
1154         put_net(net);
1155         dprintk("RPC:   sending pipefs UMOUNT notification for net %p%s\n", net,
1156                                                                 NET_NAME(net));
1157         blocking_notifier_call_chain(&rpc_pipefs_notifier_list,
1158                                            RPC_PIPEFS_UMOUNT,
1159                                            sb);
1160         kill_litter_super(sb);
1161 }
1162
1163 static struct file_system_type rpc_pipe_fs_type = {
1164         .owner          = THIS_MODULE,
1165         .name           = "rpc_pipefs",
1166         .mount          = rpc_mount,
1167         .kill_sb        = rpc_kill_sb,
1168 };
1169
1170 static void
1171 init_once(void *foo)
1172 {
1173         struct rpc_inode *rpci = (struct rpc_inode *) foo;
1174
1175         inode_init_once(&rpci->vfs_inode);
1176         rpci->private = NULL;
1177         rpci->pipe = NULL;
1178 }
1179
1180 int register_rpc_pipefs(void)
1181 {
1182         int err;
1183
1184         rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
1185                                 sizeof(struct rpc_inode),
1186                                 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
1187                                                 SLAB_MEM_SPREAD),
1188                                 init_once);
1189         if (!rpc_inode_cachep)
1190                 return -ENOMEM;
1191         err = register_filesystem(&rpc_pipe_fs_type);
1192         if (err) {
1193                 kmem_cache_destroy(rpc_inode_cachep);
1194                 return err;
1195         }
1196
1197         return 0;
1198 }
1199
1200 void unregister_rpc_pipefs(void)
1201 {
1202         kmem_cache_destroy(rpc_inode_cachep);
1203         unregister_filesystem(&rpc_pipe_fs_type);
1204 }
1205
1206 /* Make 'mount -t rpc_pipefs ...' autoload this module. */
1207 MODULE_ALIAS("rpc_pipefs");