SUNRPC: Ensure that rpc_mkpipe returns a refcounted dentry
[linux-2.6] / 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/config.h>
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/namei.h>
18 #include <linux/dnotify.h>
19 #include <linux/kernel.h>
20
21 #include <asm/ioctls.h>
22 #include <linux/fs.h>
23 #include <linux/poll.h>
24 #include <linux/wait.h>
25 #include <linux/seq_file.h>
26
27 #include <linux/sunrpc/clnt.h>
28 #include <linux/workqueue.h>
29 #include <linux/sunrpc/rpc_pipe_fs.h>
30
31 static struct vfsmount *rpc_mount __read_mostly;
32 static int rpc_mount_count;
33
34 static struct file_system_type rpc_pipe_fs_type;
35
36
37 static kmem_cache_t *rpc_inode_cachep __read_mostly;
38
39 #define RPC_UPCALL_TIMEOUT (30*HZ)
40
41 static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
42                 void (*destroy_msg)(struct rpc_pipe_msg *), int err)
43 {
44         struct rpc_pipe_msg *msg;
45
46         if (list_empty(head))
47                 return;
48         do {
49                 msg = list_entry(head->next, struct rpc_pipe_msg, list);
50                 list_del(&msg->list);
51                 msg->errno = err;
52                 destroy_msg(msg);
53         } while (!list_empty(head));
54         wake_up(&rpci->waitq);
55 }
56
57 static void
58 rpc_timeout_upcall_queue(void *data)
59 {
60         LIST_HEAD(free_list);
61         struct rpc_inode *rpci = (struct rpc_inode *)data;
62         struct inode *inode = &rpci->vfs_inode;
63         void (*destroy_msg)(struct rpc_pipe_msg *);
64
65         spin_lock(&inode->i_lock);
66         if (rpci->ops == NULL) {
67                 spin_unlock(&inode->i_lock);
68                 return;
69         }
70         destroy_msg = rpci->ops->destroy_msg;
71         if (rpci->nreaders == 0) {
72                 list_splice_init(&rpci->pipe, &free_list);
73                 rpci->pipelen = 0;
74         }
75         spin_unlock(&inode->i_lock);
76         rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT);
77 }
78
79 int
80 rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
81 {
82         struct rpc_inode *rpci = RPC_I(inode);
83         int res = -EPIPE;
84
85         spin_lock(&inode->i_lock);
86         if (rpci->ops == NULL)
87                 goto out;
88         if (rpci->nreaders) {
89                 list_add_tail(&msg->list, &rpci->pipe);
90                 rpci->pipelen += msg->len;
91                 res = 0;
92         } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
93                 if (list_empty(&rpci->pipe))
94                         queue_delayed_work(rpciod_workqueue,
95                                         &rpci->queue_timeout,
96                                         RPC_UPCALL_TIMEOUT);
97                 list_add_tail(&msg->list, &rpci->pipe);
98                 rpci->pipelen += msg->len;
99                 res = 0;
100         }
101 out:
102         spin_unlock(&inode->i_lock);
103         wake_up(&rpci->waitq);
104         return res;
105 }
106
107 static inline void
108 rpc_inode_setowner(struct inode *inode, void *private)
109 {
110         RPC_I(inode)->private = private;
111 }
112
113 static void
114 rpc_close_pipes(struct inode *inode)
115 {
116         struct rpc_inode *rpci = RPC_I(inode);
117         struct rpc_pipe_ops *ops;
118
119         mutex_lock(&inode->i_mutex);
120         ops = rpci->ops;
121         if (ops != NULL) {
122                 LIST_HEAD(free_list);
123
124                 spin_lock(&inode->i_lock);
125                 rpci->nreaders = 0;
126                 list_splice_init(&rpci->in_upcall, &free_list);
127                 list_splice_init(&rpci->pipe, &free_list);
128                 rpci->pipelen = 0;
129                 rpci->ops = NULL;
130                 spin_unlock(&inode->i_lock);
131                 rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
132                 rpci->nwriters = 0;
133                 if (ops->release_pipe)
134                         ops->release_pipe(inode);
135                 cancel_delayed_work(&rpci->queue_timeout);
136                 flush_workqueue(rpciod_workqueue);
137         }
138         rpc_inode_setowner(inode, NULL);
139         mutex_unlock(&inode->i_mutex);
140 }
141
142 static struct inode *
143 rpc_alloc_inode(struct super_block *sb)
144 {
145         struct rpc_inode *rpci;
146         rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, SLAB_KERNEL);
147         if (!rpci)
148                 return NULL;
149         return &rpci->vfs_inode;
150 }
151
152 static void
153 rpc_destroy_inode(struct inode *inode)
154 {
155         kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
156 }
157
158 static int
159 rpc_pipe_open(struct inode *inode, struct file *filp)
160 {
161         struct rpc_inode *rpci = RPC_I(inode);
162         int res = -ENXIO;
163
164         mutex_lock(&inode->i_mutex);
165         if (rpci->ops != NULL) {
166                 if (filp->f_mode & FMODE_READ)
167                         rpci->nreaders ++;
168                 if (filp->f_mode & FMODE_WRITE)
169                         rpci->nwriters ++;
170                 res = 0;
171         }
172         mutex_unlock(&inode->i_mutex);
173         return res;
174 }
175
176 static int
177 rpc_pipe_release(struct inode *inode, struct file *filp)
178 {
179         struct rpc_inode *rpci = RPC_I(inode);
180         struct rpc_pipe_msg *msg;
181
182         mutex_lock(&inode->i_mutex);
183         if (rpci->ops == NULL)
184                 goto out;
185         msg = (struct rpc_pipe_msg *)filp->private_data;
186         if (msg != NULL) {
187                 spin_lock(&inode->i_lock);
188                 msg->errno = -EAGAIN;
189                 list_del(&msg->list);
190                 spin_unlock(&inode->i_lock);
191                 rpci->ops->destroy_msg(msg);
192         }
193         if (filp->f_mode & FMODE_WRITE)
194                 rpci->nwriters --;
195         if (filp->f_mode & FMODE_READ) {
196                 rpci->nreaders --;
197                 if (rpci->nreaders == 0) {
198                         LIST_HEAD(free_list);
199                         spin_lock(&inode->i_lock);
200                         list_splice_init(&rpci->pipe, &free_list);
201                         rpci->pipelen = 0;
202                         spin_unlock(&inode->i_lock);
203                         rpc_purge_list(rpci, &free_list,
204                                         rpci->ops->destroy_msg, -EAGAIN);
205                 }
206         }
207         if (rpci->ops->release_pipe)
208                 rpci->ops->release_pipe(inode);
209 out:
210         mutex_unlock(&inode->i_mutex);
211         return 0;
212 }
213
214 static ssize_t
215 rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
216 {
217         struct inode *inode = filp->f_dentry->d_inode;
218         struct rpc_inode *rpci = RPC_I(inode);
219         struct rpc_pipe_msg *msg;
220         int res = 0;
221
222         mutex_lock(&inode->i_mutex);
223         if (rpci->ops == NULL) {
224                 res = -EPIPE;
225                 goto out_unlock;
226         }
227         msg = filp->private_data;
228         if (msg == NULL) {
229                 spin_lock(&inode->i_lock);
230                 if (!list_empty(&rpci->pipe)) {
231                         msg = list_entry(rpci->pipe.next,
232                                         struct rpc_pipe_msg,
233                                         list);
234                         list_move(&msg->list, &rpci->in_upcall);
235                         rpci->pipelen -= msg->len;
236                         filp->private_data = msg;
237                         msg->copied = 0;
238                 }
239                 spin_unlock(&inode->i_lock);
240                 if (msg == NULL)
241                         goto out_unlock;
242         }
243         /* NOTE: it is up to the callback to update msg->copied */
244         res = rpci->ops->upcall(filp, msg, buf, len);
245         if (res < 0 || msg->len == msg->copied) {
246                 filp->private_data = NULL;
247                 spin_lock(&inode->i_lock);
248                 list_del(&msg->list);
249                 spin_unlock(&inode->i_lock);
250                 rpci->ops->destroy_msg(msg);
251         }
252 out_unlock:
253         mutex_unlock(&inode->i_mutex);
254         return res;
255 }
256
257 static ssize_t
258 rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
259 {
260         struct inode *inode = filp->f_dentry->d_inode;
261         struct rpc_inode *rpci = RPC_I(inode);
262         int res;
263
264         mutex_lock(&inode->i_mutex);
265         res = -EPIPE;
266         if (rpci->ops != NULL)
267                 res = rpci->ops->downcall(filp, buf, len);
268         mutex_unlock(&inode->i_mutex);
269         return res;
270 }
271
272 static unsigned int
273 rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
274 {
275         struct rpc_inode *rpci;
276         unsigned int mask = 0;
277
278         rpci = RPC_I(filp->f_dentry->d_inode);
279         poll_wait(filp, &rpci->waitq, wait);
280
281         mask = POLLOUT | POLLWRNORM;
282         if (rpci->ops == NULL)
283                 mask |= POLLERR | POLLHUP;
284         if (!list_empty(&rpci->pipe))
285                 mask |= POLLIN | POLLRDNORM;
286         return mask;
287 }
288
289 static int
290 rpc_pipe_ioctl(struct inode *ino, struct file *filp,
291                 unsigned int cmd, unsigned long arg)
292 {
293         struct rpc_inode *rpci = RPC_I(filp->f_dentry->d_inode);
294         int len;
295
296         switch (cmd) {
297         case FIONREAD:
298                 if (rpci->ops == NULL)
299                         return -EPIPE;
300                 len = rpci->pipelen;
301                 if (filp->private_data) {
302                         struct rpc_pipe_msg *msg;
303                         msg = (struct rpc_pipe_msg *)filp->private_data;
304                         len += msg->len - msg->copied;
305                 }
306                 return put_user(len, (int __user *)arg);
307         default:
308                 return -EINVAL;
309         }
310 }
311
312 static struct file_operations rpc_pipe_fops = {
313         .owner          = THIS_MODULE,
314         .llseek         = no_llseek,
315         .read           = rpc_pipe_read,
316         .write          = rpc_pipe_write,
317         .poll           = rpc_pipe_poll,
318         .ioctl          = rpc_pipe_ioctl,
319         .open           = rpc_pipe_open,
320         .release        = rpc_pipe_release,
321 };
322
323 static int
324 rpc_show_info(struct seq_file *m, void *v)
325 {
326         struct rpc_clnt *clnt = m->private;
327
328         seq_printf(m, "RPC server: %s\n", clnt->cl_server);
329         seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
330                         clnt->cl_prog, clnt->cl_vers);
331         seq_printf(m, "address: %u.%u.%u.%u\n",
332                         NIPQUAD(clnt->cl_xprt->addr.sin_addr.s_addr));
333         seq_printf(m, "protocol: %s\n",
334                         clnt->cl_xprt->prot == IPPROTO_UDP ? "udp" : "tcp");
335         return 0;
336 }
337
338 static int
339 rpc_info_open(struct inode *inode, struct file *file)
340 {
341         struct rpc_clnt *clnt;
342         int ret = single_open(file, rpc_show_info, NULL);
343
344         if (!ret) {
345                 struct seq_file *m = file->private_data;
346                 mutex_lock(&inode->i_mutex);
347                 clnt = RPC_I(inode)->private;
348                 if (clnt) {
349                         atomic_inc(&clnt->cl_users);
350                         m->private = clnt;
351                 } else {
352                         single_release(inode, file);
353                         ret = -EINVAL;
354                 }
355                 mutex_unlock(&inode->i_mutex);
356         }
357         return ret;
358 }
359
360 static int
361 rpc_info_release(struct inode *inode, struct file *file)
362 {
363         struct seq_file *m = file->private_data;
364         struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
365
366         if (clnt)
367                 rpc_release_client(clnt);
368         return single_release(inode, file);
369 }
370
371 static struct file_operations rpc_info_operations = {
372         .owner          = THIS_MODULE,
373         .open           = rpc_info_open,
374         .read           = seq_read,
375         .llseek         = seq_lseek,
376         .release        = rpc_info_release,
377 };
378
379
380 /*
381  * We have a single directory with 1 node in it.
382  */
383 enum {
384         RPCAUTH_Root = 1,
385         RPCAUTH_lockd,
386         RPCAUTH_mount,
387         RPCAUTH_nfs,
388         RPCAUTH_portmap,
389         RPCAUTH_statd,
390         RPCAUTH_RootEOF
391 };
392
393 /*
394  * Description of fs contents.
395  */
396 struct rpc_filelist {
397         char *name;
398         struct file_operations *i_fop;
399         int mode;
400 };
401
402 static struct rpc_filelist files[] = {
403         [RPCAUTH_lockd] = {
404                 .name = "lockd",
405                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
406         },
407         [RPCAUTH_mount] = {
408                 .name = "mount",
409                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
410         },
411         [RPCAUTH_nfs] = {
412                 .name = "nfs",
413                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
414         },
415         [RPCAUTH_portmap] = {
416                 .name = "portmap",
417                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
418         },
419         [RPCAUTH_statd] = {
420                 .name = "statd",
421                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
422         },
423 };
424
425 enum {
426         RPCAUTH_info = 2,
427         RPCAUTH_EOF
428 };
429
430 static struct rpc_filelist authfiles[] = {
431         [RPCAUTH_info] = {
432                 .name = "info",
433                 .i_fop = &rpc_info_operations,
434                 .mode = S_IFREG | S_IRUSR,
435         },
436 };
437
438 static int
439 rpc_get_mount(void)
440 {
441         return simple_pin_fs("rpc_pipefs", &rpc_mount, &rpc_mount_count);
442 }
443
444 static void
445 rpc_put_mount(void)
446 {
447         simple_release_fs(&rpc_mount, &rpc_mount_count);
448 }
449
450 static int
451 rpc_lookup_parent(char *path, struct nameidata *nd)
452 {
453         if (path[0] == '\0')
454                 return -ENOENT;
455         if (rpc_get_mount()) {
456                 printk(KERN_WARNING "%s: %s failed to mount "
457                                "pseudofilesystem \n", __FILE__, __FUNCTION__);
458                 return -ENODEV;
459         }
460         nd->mnt = mntget(rpc_mount);
461         nd->dentry = dget(rpc_mount->mnt_root);
462         nd->last_type = LAST_ROOT;
463         nd->flags = LOOKUP_PARENT;
464         nd->depth = 0;
465
466         if (path_walk(path, nd)) {
467                 printk(KERN_WARNING "%s: %s failed to find path %s\n",
468                                 __FILE__, __FUNCTION__, path);
469                 rpc_put_mount();
470                 return -ENOENT;
471         }
472         return 0;
473 }
474
475 static void
476 rpc_release_path(struct nameidata *nd)
477 {
478         path_release(nd);
479         rpc_put_mount();
480 }
481
482 static struct inode *
483 rpc_get_inode(struct super_block *sb, int mode)
484 {
485         struct inode *inode = new_inode(sb);
486         if (!inode)
487                 return NULL;
488         inode->i_mode = mode;
489         inode->i_uid = inode->i_gid = 0;
490         inode->i_blksize = PAGE_CACHE_SIZE;
491         inode->i_blocks = 0;
492         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
493         switch(mode & S_IFMT) {
494                 case S_IFDIR:
495                         inode->i_fop = &simple_dir_operations;
496                         inode->i_op = &simple_dir_inode_operations;
497                         inode->i_nlink++;
498                 default:
499                         break;
500         }
501         return inode;
502 }
503
504 /*
505  * FIXME: This probably has races.
506  */
507 static void
508 rpc_depopulate(struct dentry *parent)
509 {
510         struct inode *dir = parent->d_inode;
511         struct list_head *pos, *next;
512         struct dentry *dentry, *dvec[10];
513         int n = 0;
514
515         mutex_lock(&dir->i_mutex);
516 repeat:
517         spin_lock(&dcache_lock);
518         list_for_each_safe(pos, next, &parent->d_subdirs) {
519                 dentry = list_entry(pos, struct dentry, d_u.d_child);
520                 spin_lock(&dentry->d_lock);
521                 if (!d_unhashed(dentry)) {
522                         dget_locked(dentry);
523                         __d_drop(dentry);
524                         spin_unlock(&dentry->d_lock);
525                         dvec[n++] = dentry;
526                         if (n == ARRAY_SIZE(dvec))
527                                 break;
528                 } else
529                         spin_unlock(&dentry->d_lock);
530         }
531         spin_unlock(&dcache_lock);
532         if (n) {
533                 do {
534                         dentry = dvec[--n];
535                         if (dentry->d_inode) {
536                                 rpc_close_pipes(dentry->d_inode);
537                                 simple_unlink(dir, dentry);
538                         }
539                         dput(dentry);
540                 } while (n);
541                 goto repeat;
542         }
543         mutex_unlock(&dir->i_mutex);
544 }
545
546 static int
547 rpc_populate(struct dentry *parent,
548                 struct rpc_filelist *files,
549                 int start, int eof)
550 {
551         struct inode *inode, *dir = parent->d_inode;
552         void *private = RPC_I(dir)->private;
553         struct dentry *dentry;
554         int mode, i;
555
556         mutex_lock(&dir->i_mutex);
557         for (i = start; i < eof; i++) {
558                 dentry = d_alloc_name(parent, files[i].name);
559                 if (!dentry)
560                         goto out_bad;
561                 mode = files[i].mode;
562                 inode = rpc_get_inode(dir->i_sb, mode);
563                 if (!inode) {
564                         dput(dentry);
565                         goto out_bad;
566                 }
567                 inode->i_ino = i;
568                 if (files[i].i_fop)
569                         inode->i_fop = files[i].i_fop;
570                 if (private)
571                         rpc_inode_setowner(inode, private);
572                 if (S_ISDIR(mode))
573                         dir->i_nlink++;
574                 d_add(dentry, inode);
575         }
576         mutex_unlock(&dir->i_mutex);
577         return 0;
578 out_bad:
579         mutex_unlock(&dir->i_mutex);
580         printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
581                         __FILE__, __FUNCTION__, parent->d_name.name);
582         return -ENOMEM;
583 }
584
585 static int
586 __rpc_mkdir(struct inode *dir, struct dentry *dentry)
587 {
588         struct inode *inode;
589
590         inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
591         if (!inode)
592                 goto out_err;
593         inode->i_ino = iunique(dir->i_sb, 100);
594         d_instantiate(dentry, inode);
595         dir->i_nlink++;
596         inode_dir_notify(dir, DN_CREATE);
597         rpc_get_mount();
598         return 0;
599 out_err:
600         printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
601                         __FILE__, __FUNCTION__, dentry->d_name.name);
602         return -ENOMEM;
603 }
604
605 static int
606 __rpc_rmdir(struct inode *dir, struct dentry *dentry)
607 {
608         int error;
609
610         shrink_dcache_parent(dentry);
611         if (dentry->d_inode)
612                 rpc_close_pipes(dentry->d_inode);
613         if ((error = simple_rmdir(dir, dentry)) != 0)
614                 return error;
615         if (!error) {
616                 inode_dir_notify(dir, DN_DELETE);
617                 d_drop(dentry);
618                 rpc_put_mount();
619         }
620         return 0;
621 }
622
623 static struct dentry *
624 rpc_lookup_negative(char *path, struct nameidata *nd)
625 {
626         struct dentry *dentry;
627         struct inode *dir;
628         int error;
629
630         if ((error = rpc_lookup_parent(path, nd)) != 0)
631                 return ERR_PTR(error);
632         dir = nd->dentry->d_inode;
633         mutex_lock(&dir->i_mutex);
634         dentry = lookup_one_len(nd->last.name, nd->dentry, nd->last.len);
635         if (IS_ERR(dentry))
636                 goto out_err;
637         if (dentry->d_inode) {
638                 dput(dentry);
639                 dentry = ERR_PTR(-EEXIST);
640                 goto out_err;
641         }
642         return dentry;
643 out_err:
644         mutex_unlock(&dir->i_mutex);
645         rpc_release_path(nd);
646         return dentry;
647 }
648
649
650 struct dentry *
651 rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
652 {
653         struct nameidata nd;
654         struct dentry *dentry;
655         struct inode *dir;
656         int error;
657
658         dentry = rpc_lookup_negative(path, &nd);
659         if (IS_ERR(dentry))
660                 return dentry;
661         dir = nd.dentry->d_inode;
662         if ((error = __rpc_mkdir(dir, dentry)) != 0)
663                 goto err_dput;
664         RPC_I(dentry->d_inode)->private = rpc_client;
665         error = rpc_populate(dentry, authfiles,
666                         RPCAUTH_info, RPCAUTH_EOF);
667         if (error)
668                 goto err_depopulate;
669 out:
670         mutex_unlock(&dir->i_mutex);
671         rpc_release_path(&nd);
672         return dget(dentry);
673 err_depopulate:
674         rpc_depopulate(dentry);
675         __rpc_rmdir(dir, dentry);
676 err_dput:
677         dput(dentry);
678         printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
679                         __FILE__, __FUNCTION__, path, error);
680         dentry = ERR_PTR(error);
681         goto out;
682 }
683
684 int
685 rpc_rmdir(char *path)
686 {
687         struct nameidata nd;
688         struct dentry *dentry;
689         struct inode *dir;
690         int error;
691
692         if ((error = rpc_lookup_parent(path, &nd)) != 0)
693                 return error;
694         dir = nd.dentry->d_inode;
695         mutex_lock(&dir->i_mutex);
696         dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
697         if (IS_ERR(dentry)) {
698                 error = PTR_ERR(dentry);
699                 goto out_release;
700         }
701         rpc_depopulate(dentry);
702         error = __rpc_rmdir(dir, dentry);
703         dput(dentry);
704 out_release:
705         mutex_unlock(&dir->i_mutex);
706         rpc_release_path(&nd);
707         return error;
708 }
709
710 struct dentry *
711 rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
712 {
713         struct nameidata nd;
714         struct dentry *dentry;
715         struct inode *dir, *inode;
716         struct rpc_inode *rpci;
717
718         dentry = rpc_lookup_negative(path, &nd);
719         if (IS_ERR(dentry))
720                 return dentry;
721         dir = nd.dentry->d_inode;
722         inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
723         if (!inode)
724                 goto err_dput;
725         inode->i_ino = iunique(dir->i_sb, 100);
726         inode->i_fop = &rpc_pipe_fops;
727         d_instantiate(dentry, inode);
728         rpci = RPC_I(inode);
729         rpci->private = private;
730         rpci->flags = flags;
731         rpci->ops = ops;
732         inode_dir_notify(dir, DN_CREATE);
733 out:
734         mutex_unlock(&dir->i_mutex);
735         rpc_release_path(&nd);
736         return dget(dentry);
737 err_dput:
738         dput(dentry);
739         dentry = ERR_PTR(-ENOMEM);
740         printk(KERN_WARNING "%s: %s() failed to create pipe %s (errno = %d)\n",
741                         __FILE__, __FUNCTION__, path, -ENOMEM);
742         goto out;
743 }
744
745 int
746 rpc_unlink(char *path)
747 {
748         struct nameidata nd;
749         struct dentry *dentry;
750         struct inode *dir;
751         int error;
752
753         if ((error = rpc_lookup_parent(path, &nd)) != 0)
754                 return error;
755         dir = nd.dentry->d_inode;
756         mutex_lock(&dir->i_mutex);
757         dentry = lookup_one_len(nd.last.name, nd.dentry, nd.last.len);
758         if (IS_ERR(dentry)) {
759                 error = PTR_ERR(dentry);
760                 goto out_release;
761         }
762         d_drop(dentry);
763         if (dentry->d_inode) {
764                 rpc_close_pipes(dentry->d_inode);
765                 error = simple_unlink(dir, dentry);
766         }
767         dput(dentry);
768         inode_dir_notify(dir, DN_DELETE);
769 out_release:
770         mutex_unlock(&dir->i_mutex);
771         rpc_release_path(&nd);
772         return error;
773 }
774
775 /*
776  * populate the filesystem
777  */
778 static struct super_operations s_ops = {
779         .alloc_inode    = rpc_alloc_inode,
780         .destroy_inode  = rpc_destroy_inode,
781         .statfs         = simple_statfs,
782 };
783
784 #define RPCAUTH_GSSMAGIC 0x67596969
785
786 static int
787 rpc_fill_super(struct super_block *sb, void *data, int silent)
788 {
789         struct inode *inode;
790         struct dentry *root;
791
792         sb->s_blocksize = PAGE_CACHE_SIZE;
793         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
794         sb->s_magic = RPCAUTH_GSSMAGIC;
795         sb->s_op = &s_ops;
796         sb->s_time_gran = 1;
797
798         inode = rpc_get_inode(sb, S_IFDIR | 0755);
799         if (!inode)
800                 return -ENOMEM;
801         root = d_alloc_root(inode);
802         if (!root) {
803                 iput(inode);
804                 return -ENOMEM;
805         }
806         if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
807                 goto out;
808         sb->s_root = root;
809         return 0;
810 out:
811         d_genocide(root);
812         dput(root);
813         return -ENOMEM;
814 }
815
816 static struct super_block *
817 rpc_get_sb(struct file_system_type *fs_type,
818                 int flags, const char *dev_name, void *data)
819 {
820         return get_sb_single(fs_type, flags, data, rpc_fill_super);
821 }
822
823 static struct file_system_type rpc_pipe_fs_type = {
824         .owner          = THIS_MODULE,
825         .name           = "rpc_pipefs",
826         .get_sb         = rpc_get_sb,
827         .kill_sb        = kill_litter_super,
828 };
829
830 static void
831 init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
832 {
833         struct rpc_inode *rpci = (struct rpc_inode *) foo;
834
835         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
836             SLAB_CTOR_CONSTRUCTOR) {
837                 inode_init_once(&rpci->vfs_inode);
838                 rpci->private = NULL;
839                 rpci->nreaders = 0;
840                 rpci->nwriters = 0;
841                 INIT_LIST_HEAD(&rpci->in_upcall);
842                 INIT_LIST_HEAD(&rpci->pipe);
843                 rpci->pipelen = 0;
844                 init_waitqueue_head(&rpci->waitq);
845                 INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
846                 rpci->ops = NULL;
847         }
848 }
849
850 int register_rpc_pipefs(void)
851 {
852         rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
853                                              sizeof(struct rpc_inode),
854                                              0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
855                                              init_once, NULL);
856         if (!rpc_inode_cachep)
857                 return -ENOMEM;
858         register_filesystem(&rpc_pipe_fs_type);
859         return 0;
860 }
861
862 void unregister_rpc_pipefs(void)
863 {
864         if (kmem_cache_destroy(rpc_inode_cachep))
865                 printk(KERN_WARNING "RPC: unable to free inode cache\n");
866         unregister_filesystem(&rpc_pipe_fs_type);
867 }