ia64/linux-2.6.18-xen.hg

view net/sunrpc/rpc_pipe.c @ 871:9cbcc9008446

xen/x86: don't initialize cpu_data[]'s apicid field on generic code

Afaict, this is not only redundant with the intialization done in
drivers/xen/core/smpboot.c, but actually results - at least for
secondary CPUs - in the Xen-specific value written to be later
overwritten with whatever the generic code determines (with no
guarantee that the two values are identical).

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