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