?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.31.6
[linux/fpc-iii.git] / net / sunrpc / rpc_pipe.c
blob9ced0628d69c35d44aa158b6d615acf8086278c6
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
30 static struct vfsmount *rpc_mount __read_mostly;
31 static int rpc_mount_count;
32
33 static struct file_system_type rpc_pipe_fs_type;
34
35
36 static struct kmem_cache *rpc_inode_cachep __read_mostly;
37
38 #define RPC_UPCALL_TIMEOUT (30*HZ)
39
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;
44
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 }
55
56 static void
57 rpc_timeout_upcall_queue(struct work_struct *work)
58 {
59 LIST_HEAD(free_list);
60 struct rpc_inode *rpci =
61 container_of(work, struct rpc_inode, queue_timeout.work);
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 /**
80 * rpc_queue_upcall
81 * @inode: inode of upcall pipe on which to queue given message
82 * @msg: message to queue
83 *
84 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
85 * A userspace process may then later read the upcall by performing a
86 * read on an open file for this inode. It is up to the caller to
87 * initialize the fields of @msg (other than @msg->list) appropriately.
88 */
89 int
90 rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
91 {
92 struct rpc_inode *rpci = RPC_I(inode);
93 int res = -EPIPE;
94
95 spin_lock(&inode->i_lock);
96 if (rpci->ops == NULL)
97 goto out;
98 if (rpci->nreaders) {
99 list_add_tail(&msg->list, &rpci->pipe);
100 rpci->pipelen += msg->len;
101 res = 0;
102 } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
103 if (list_empty(&rpci->pipe))
104 queue_delayed_work(rpciod_workqueue,
105 &rpci->queue_timeout,
106 RPC_UPCALL_TIMEOUT);
107 list_add_tail(&msg->list, &rpci->pipe);
108 rpci->pipelen += msg->len;
109 res = 0;
110 }
111 out:
112 spin_unlock(&inode->i_lock);
113 wake_up(&rpci->waitq);
114 return res;
115 }
116 EXPORT_SYMBOL_GPL(rpc_queue_upcall);
117
118 static inline void
119 rpc_inode_setowner(struct inode *inode, void *private)
120 {
121 RPC_I(inode)->private = private;
122 }
123
124 static void
125 rpc_close_pipes(struct inode *inode)
126 {
127 struct rpc_inode *rpci = RPC_I(inode);
128 struct rpc_pipe_ops *ops;
129 int need_release;
130
131 mutex_lock(&inode->i_mutex);
132 ops = rpci->ops;
133 if (ops != NULL) {
134 LIST_HEAD(free_list);
135 spin_lock(&inode->i_lock);
136 need_release = rpci->nreaders != 0 || rpci->nwriters != 0;
137 rpci->nreaders = 0;
138 list_splice_init(&rpci->in_upcall, &free_list);
139 list_splice_init(&rpci->pipe, &free_list);
140 rpci->pipelen = 0;
141 rpci->ops = NULL;
142 spin_unlock(&inode->i_lock);
143 rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
144 rpci->nwriters = 0;
145 if (need_release && ops->release_pipe)
146 ops->release_pipe(inode);
147 cancel_delayed_work_sync(&rpci->queue_timeout);
148 }
149 rpc_inode_setowner(inode, NULL);
150 mutex_unlock(&inode->i_mutex);
151 }
152
153 static struct inode *
154 rpc_alloc_inode(struct super_block *sb)
155 {
156 struct rpc_inode *rpci;
157 rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
158 if (!rpci)
159 return NULL;
160 return &rpci->vfs_inode;
161 }
162
163 static void
164 rpc_destroy_inode(struct inode *inode)
165 {
166 kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
167 }
168
169 static int
170 rpc_pipe_open(struct inode *inode, struct file *filp)
171 {
172 struct rpc_inode *rpci = RPC_I(inode);
173 int first_open;
174 int res = -ENXIO;
175
176 mutex_lock(&inode->i_mutex);
177 if (rpci->ops == NULL)
178 goto out;
179 first_open = rpci->nreaders == 0 && rpci->nwriters == 0;
180 if (first_open && rpci->ops->open_pipe) {
181 res = rpci->ops->open_pipe(inode);
182 if (res)
183 goto out;
184 }
185 if (filp->f_mode & FMODE_READ)
186 rpci->nreaders++;
187 if (filp->f_mode & FMODE_WRITE)
188 rpci->nwriters++;
189 res = 0;
190 out:
191 mutex_unlock(&inode->i_mutex);
192 return res;
193 }
194
195 static int
196 rpc_pipe_release(struct inode *inode, struct file *filp)
197 {
198 struct rpc_inode *rpci = RPC_I(inode);
199 struct rpc_pipe_msg *msg;
200 int last_close;
201
202 mutex_lock(&inode->i_mutex);
203 if (rpci->ops == NULL)
204 goto out;
205 msg = (struct rpc_pipe_msg *)filp->private_data;
206 if (msg != NULL) {
207 spin_lock(&inode->i_lock);
208 msg->errno = -EAGAIN;
209 list_del(&msg->list);
210 spin_unlock(&inode->i_lock);
211 rpci->ops->destroy_msg(msg);
212 }
213 if (filp->f_mode & FMODE_WRITE)
214 rpci->nwriters --;
215 if (filp->f_mode & FMODE_READ) {
216 rpci->nreaders --;
217 if (rpci->nreaders == 0) {
218 LIST_HEAD(free_list);
219 spin_lock(&inode->i_lock);
220 list_splice_init(&rpci->pipe, &free_list);
221 rpci->pipelen = 0;
222 spin_unlock(&inode->i_lock);
223 rpc_purge_list(rpci, &free_list,
224 rpci->ops->destroy_msg, -EAGAIN);
225 }
226 }
227 last_close = rpci->nwriters == 0 && rpci->nreaders == 0;
228 if (last_close && rpci->ops->release_pipe)
229 rpci->ops->release_pipe(inode);
230 out:
231 mutex_unlock(&inode->i_mutex);
232 return 0;
233 }
234
235 static ssize_t
236 rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
237 {
238 struct inode *inode = filp->f_path.dentry->d_inode;
239 struct rpc_inode *rpci = RPC_I(inode);
240 struct rpc_pipe_msg *msg;
241 int res = 0;
242
243 mutex_lock(&inode->i_mutex);
244 if (rpci->ops == NULL) {
245 res = -EPIPE;
246 goto out_unlock;
247 }
248 msg = filp->private_data;
249 if (msg == NULL) {
250 spin_lock(&inode->i_lock);
251 if (!list_empty(&rpci->pipe)) {
252 msg = list_entry(rpci->pipe.next,
253 struct rpc_pipe_msg,
254 list);
255 list_move(&msg->list, &rpci->in_upcall);
256 rpci->pipelen -= msg->len;
257 filp->private_data = msg;
258 msg->copied = 0;
259 }
260 spin_unlock(&inode->i_lock);
261 if (msg == NULL)
262 goto out_unlock;
263 }
264 /* NOTE: it is up to the callback to update msg->copied */
265 res = rpci->ops->upcall(filp, msg, buf, len);
266 if (res < 0 || msg->len == msg->copied) {
267 filp->private_data = NULL;
268 spin_lock(&inode->i_lock);
269 list_del(&msg->list);
270 spin_unlock(&inode->i_lock);
271 rpci->ops->destroy_msg(msg);
272 }
273 out_unlock:
274 mutex_unlock(&inode->i_mutex);
275 return res;
276 }
277
278 static ssize_t
279 rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
280 {
281 struct inode *inode = filp->f_path.dentry->d_inode;
282 struct rpc_inode *rpci = RPC_I(inode);
283 int res;
284
285 mutex_lock(&inode->i_mutex);
286 res = -EPIPE;
287 if (rpci->ops != NULL)
288 res = rpci->ops->downcall(filp, buf, len);
289 mutex_unlock(&inode->i_mutex);
290 return res;
291 }
292
293 static unsigned int
294 rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
295 {
296 struct rpc_inode *rpci;
297 unsigned int mask = 0;
298
299 rpci = RPC_I(filp->f_path.dentry->d_inode);
300 poll_wait(filp, &rpci->waitq, wait);
301
302 mask = POLLOUT | POLLWRNORM;
303 if (rpci->ops == NULL)
304 mask |= POLLERR | POLLHUP;
305 if (filp->private_data || !list_empty(&rpci->pipe))
306 mask |= POLLIN | POLLRDNORM;
307 return mask;
308 }
309
310 static int
311 rpc_pipe_ioctl(struct inode *ino, struct file *filp,
312 unsigned int cmd, unsigned long arg)
313 {
314 struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
315 int len;
316
317 switch (cmd) {
318 case FIONREAD:
319 if (rpci->ops == NULL)
320 return -EPIPE;
321 len = rpci->pipelen;
322 if (filp->private_data) {
323 struct rpc_pipe_msg *msg;
324 msg = (struct rpc_pipe_msg *)filp->private_data;
325 len += msg->len - msg->copied;
326 }
327 return put_user(len, (int __user *)arg);
328 default:
329 return -EINVAL;
330 }
331 }
332
333 static const struct file_operations rpc_pipe_fops = {
334 .owner = THIS_MODULE,
335 .llseek = no_llseek,
336 .read = rpc_pipe_read,
337 .write = rpc_pipe_write,
338 .poll = rpc_pipe_poll,
339 .ioctl = rpc_pipe_ioctl,
340 .open = rpc_pipe_open,
341 .release = rpc_pipe_release,
342 };
343
344 static int
345 rpc_show_info(struct seq_file *m, void *v)
346 {
347 struct rpc_clnt *clnt = m->private;
348
349 seq_printf(m, "RPC server: %s\n", clnt->cl_server);
350 seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
351 clnt->cl_prog, clnt->cl_vers);
352 seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
353 seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
354 seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
355 return 0;
356 }
357
358 static int
359 rpc_info_open(struct inode *inode, struct file *file)
360 {
361 struct rpc_clnt *clnt;
362 int ret = single_open(file, rpc_show_info, NULL);
363
364 if (!ret) {
365 struct seq_file *m = file->private_data;
366 mutex_lock(&inode->i_mutex);
367 clnt = RPC_I(inode)->private;
368 if (clnt) {
369 kref_get(&clnt->cl_kref);
370 m->private = clnt;
371 } else {
372 single_release(inode, file);
373 ret = -EINVAL;
374 }
375 mutex_unlock(&inode->i_mutex);
376 }
377 return ret;
378 }
379
380 static int
381 rpc_info_release(struct inode *inode, struct file *file)
382 {
383 struct seq_file *m = file->private_data;
384 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
385
386 if (clnt)
387 rpc_release_client(clnt);
388 return single_release(inode, file);
389 }
390
391 static const struct file_operations rpc_info_operations = {
392 .owner = THIS_MODULE,
393 .open = rpc_info_open,
394 .read = seq_read,
395 .llseek = seq_lseek,
396 .release = rpc_info_release,
397 };
398
399
400 /*
401 * We have a single directory with 1 node in it.
402 */
403 enum {
404 RPCAUTH_Root = 1,
405 RPCAUTH_lockd,
406 RPCAUTH_mount,
407 RPCAUTH_nfs,
408 RPCAUTH_portmap,
409 RPCAUTH_statd,
410 RPCAUTH_nfsd4_cb,
411 RPCAUTH_RootEOF
412 };
413
414 /*
415 * Description of fs contents.
416 */
417 struct rpc_filelist {
418 char *name;
419 const struct file_operations *i_fop;
420 int mode;
421 };
422
423 static struct rpc_filelist files[] = {
424 [RPCAUTH_lockd] = {
425 .name = "lockd",
426 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
427 },
428 [RPCAUTH_mount] = {
429 .name = "mount",
430 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
431 },
432 [RPCAUTH_nfs] = {
433 .name = "nfs",
434 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
435 },
436 [RPCAUTH_portmap] = {
437 .name = "portmap",
438 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
439 },
440 [RPCAUTH_statd] = {
441 .name = "statd",
442 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
443 },
444 [RPCAUTH_nfsd4_cb] = {
445 .name = "nfsd4_cb",
446 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
447 },
448 };
449
450 enum {
451 RPCAUTH_info = 2,
452 RPCAUTH_EOF
453 };
454
455 static struct rpc_filelist authfiles[] = {
456 [RPCAUTH_info] = {
457 .name = "info",
458 .i_fop = &rpc_info_operations,
459 .mode = S_IFREG | S_IRUSR,
460 },
461 };
462
463 struct vfsmount *rpc_get_mount(void)
464 {
465 int err;
466
467 err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mount, &rpc_mount_count);
468 if (err != 0)
469 return ERR_PTR(err);
470 return rpc_mount;
471 }
472
473 void rpc_put_mount(void)
474 {
475 simple_release_fs(&rpc_mount, &rpc_mount_count);
476 }
477
478 static int rpc_delete_dentry(struct dentry *dentry)
479 {
480 return 1;
481 }
482
483 static const struct dentry_operations rpc_dentry_operations = {
484 .d_delete = rpc_delete_dentry,
485 };
486
487 static int
488 rpc_lookup_parent(char *path, struct nameidata *nd)
489 {
490 struct vfsmount *mnt;
491
492 if (path[0] == '\0')
493 return -ENOENT;
494
495 mnt = rpc_get_mount();
496 if (IS_ERR(mnt)) {
497 printk(KERN_WARNING "%s: %s failed to mount "
498 "pseudofilesystem \n", __FILE__, __func__);
499 return PTR_ERR(mnt);
500 }
501
502 if (vfs_path_lookup(mnt->mnt_root, mnt, path, LOOKUP_PARENT, nd)) {
503 printk(KERN_WARNING "%s: %s failed to find path %s\n",
504 __FILE__, __func__, path);
505 rpc_put_mount();
506 return -ENOENT;
507 }
508 return 0;
509 }
510
511 static void
512 rpc_release_path(struct nameidata *nd)
513 {
514 path_put(&nd->path);
515 rpc_put_mount();
516 }
517
518 static struct inode *
519 rpc_get_inode(struct super_block *sb, int mode)
520 {
521 struct inode *inode = new_inode(sb);
522 if (!inode)
523 return NULL;
524 inode->i_mode = mode;
525 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
526 switch(mode & S_IFMT) {
527 case S_IFDIR:
528 inode->i_fop = &simple_dir_operations;
529 inode->i_op = &simple_dir_inode_operations;
530 inc_nlink(inode);
531 default:
532 break;
533 }
534 return inode;
535 }
536
537 /*
538 * FIXME: This probably has races.
539 */
540 static void rpc_depopulate(struct dentry *parent,
541 unsigned long start, unsigned long eof)
542 {
543 struct inode *dir = parent->d_inode;
544 struct list_head *pos, *next;
545 struct dentry *dentry, *dvec[10];
546 int n = 0;
547
548 mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
549 repeat:
550 spin_lock(&dcache_lock);
551 list_for_each_safe(pos, next, &parent->d_subdirs) {
552 dentry = list_entry(pos, struct dentry, d_u.d_child);
553 if (!dentry->d_inode ||
554 dentry->d_inode->i_ino < start ||
555 dentry->d_inode->i_ino >= eof)
556 continue;
557 spin_lock(&dentry->d_lock);
558 if (!d_unhashed(dentry)) {
559 dget_locked(dentry);
560 __d_drop(dentry);
561 spin_unlock(&dentry->d_lock);
562 dvec[n++] = dentry;
563 if (n == ARRAY_SIZE(dvec))
564 break;
565 } else
566 spin_unlock(&dentry->d_lock);
567 }
568 spin_unlock(&dcache_lock);
569 if (n) {
570 do {
571 dentry = dvec[--n];
572 if (S_ISREG(dentry->d_inode->i_mode))
573 simple_unlink(dir, dentry);
574 else if (S_ISDIR(dentry->d_inode->i_mode))
575 simple_rmdir(dir, dentry);
576 d_delete(dentry);
577 dput(dentry);
578 } while (n);
579 goto repeat;
580 }
581 mutex_unlock(&dir->i_mutex);
582 }
583
584 static int
585 rpc_populate(struct dentry *parent,
586 struct rpc_filelist *files,
587 int start, int eof)
588 {
589 struct inode *inode, *dir = parent->d_inode;
590 void *private = RPC_I(dir)->private;
591 struct dentry *dentry;
592 int mode, i;
593
594 mutex_lock(&dir->i_mutex);
595 for (i = start; i < eof; i++) {
596 dentry = d_alloc_name(parent, files[i].name);
597 if (!dentry)
598 goto out_bad;
599 dentry->d_op = &rpc_dentry_operations;
600 mode = files[i].mode;
601 inode = rpc_get_inode(dir->i_sb, mode);
602 if (!inode) {
603 dput(dentry);
604 goto out_bad;
605 }
606 inode->i_ino = i;
607 if (files[i].i_fop)
608 inode->i_fop = files[i].i_fop;
609 if (private)
610 rpc_inode_setowner(inode, private);
611 if (S_ISDIR(mode))
612 inc_nlink(dir);
613 d_add(dentry, inode);
614 fsnotify_create(dir, dentry);
615 }
616 mutex_unlock(&dir->i_mutex);
617 return 0;
618 out_bad:
619 mutex_unlock(&dir->i_mutex);
620 printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
621 __FILE__, __func__, parent->d_name.name);
622 return -ENOMEM;
623 }
624
625 static int
626 __rpc_mkdir(struct inode *dir, struct dentry *dentry)
627 {
628 struct inode *inode;
629
630 inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO);
631 if (!inode)
632 goto out_err;
633 inode->i_ino = iunique(dir->i_sb, 100);
634 d_instantiate(dentry, inode);
635 inc_nlink(dir);
636 fsnotify_mkdir(dir, dentry);
637 return 0;
638 out_err:
639 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
640 __FILE__, __func__, dentry->d_name.name);
641 return -ENOMEM;
642 }
643
644 static int
645 __rpc_rmdir(struct inode *dir, struct dentry *dentry)
646 {
647 int error;
648 error = simple_rmdir(dir, dentry);
649 if (!error)
650 d_delete(dentry);
651 return error;
652 }
653
654 static struct dentry *
655 rpc_lookup_create(struct dentry *parent, const char *name, int len, int exclusive)
656 {
657 struct inode *dir = parent->d_inode;
658 struct dentry *dentry;
659
660 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
661 dentry = lookup_one_len(name, parent, len);
662 if (IS_ERR(dentry))
663 goto out_err;
664 if (!dentry->d_inode)
665 dentry->d_op = &rpc_dentry_operations;
666 else if (exclusive) {
667 dput(dentry);
668 dentry = ERR_PTR(-EEXIST);
669 goto out_err;
670 }
671 return dentry;
672 out_err:
673 mutex_unlock(&dir->i_mutex);
674 return dentry;
675 }
676
677 static struct dentry *
678 rpc_lookup_negative(char *path, struct nameidata *nd)
679 {
680 struct dentry *dentry;
681 int error;
682
683 if ((error = rpc_lookup_parent(path, nd)) != 0)
684 return ERR_PTR(error);
685 dentry = rpc_lookup_create(nd->path.dentry, nd->last.name, nd->last.len,
686 1);
687 if (IS_ERR(dentry))
688 rpc_release_path(nd);
689 return dentry;
690 }
691
692 /**
693 * rpc_mkdir - Create a new directory in rpc_pipefs
694 * @path: path from the rpc_pipefs root to the new directory
695 * @rpc_client: rpc client to associate with this directory
696 *
697 * This creates a directory at the given @path associated with
698 * @rpc_clnt, which will contain a file named "info" with some basic
699 * information about the client, together with any "pipes" that may
700 * later be created using rpc_mkpipe().
701 */
702 struct dentry *
703 rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
704 {
705 struct nameidata nd;
706 struct dentry *dentry;
707 struct inode *dir;
708 int error;
709
710 dentry = rpc_lookup_negative(path, &nd);
711 if (IS_ERR(dentry))
712 return dentry;
713 dir = nd.path.dentry->d_inode;
714 if ((error = __rpc_mkdir(dir, dentry)) != 0)
715 goto err_dput;
716 RPC_I(dentry->d_inode)->private = rpc_client;
717 error = rpc_populate(dentry, authfiles,
718 RPCAUTH_info, RPCAUTH_EOF);
719 if (error)
720 goto err_depopulate;
721 dget(dentry);
722 out:
723 mutex_unlock(&dir->i_mutex);
724 rpc_release_path(&nd);
725 return dentry;
726 err_depopulate:
727 rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF);
728 __rpc_rmdir(dir, dentry);
729 err_dput:
730 dput(dentry);
731 printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
732 __FILE__, __func__, path, error);
733 dentry = ERR_PTR(error);
734 goto out;
735 }
736
737 /**
738 * rpc_rmdir - Remove a directory created with rpc_mkdir()
739 * @dentry: directory to remove
740 */
741 int
742 rpc_rmdir(struct dentry *dentry)
743 {
744 struct dentry *parent;
745 struct inode *dir;
746 int error;
747
748 parent = dget_parent(dentry);
749 dir = parent->d_inode;
750 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
751 rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF);
752 error = __rpc_rmdir(dir, dentry);
753 dput(dentry);
754 mutex_unlock(&dir->i_mutex);
755 dput(parent);
756 return error;
757 }
758
759 /**
760 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
761 * @parent: dentry of directory to create new "pipe" in
762 * @name: name of pipe
763 * @private: private data to associate with the pipe, for the caller's use
764 * @ops: operations defining the behavior of the pipe: upcall, downcall,
765 * release_pipe, open_pipe, and destroy_msg.
766 * @flags: rpc_inode flags
767 *
768 * Data is made available for userspace to read by calls to
769 * rpc_queue_upcall(). The actual reads will result in calls to
770 * @ops->upcall, which will be called with the file pointer,
771 * message, and userspace buffer to copy to.
772 *
773 * Writes can come at any time, and do not necessarily have to be
774 * responses to upcalls. They will result in calls to @msg->downcall.
775 *
776 * The @private argument passed here will be available to all these methods
777 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
778 */
779 struct dentry *
780 rpc_mkpipe(struct dentry *parent, const char *name, void *private, struct rpc_pipe_ops *ops, int flags)
781 {
782 struct dentry *dentry;
783 struct inode *dir, *inode;
784 struct rpc_inode *rpci;
785
786 dentry = rpc_lookup_create(parent, name, strlen(name), 0);
787 if (IS_ERR(dentry))
788 return dentry;
789 dir = parent->d_inode;
790 if (dentry->d_inode) {
791 rpci = RPC_I(dentry->d_inode);
792 if (rpci->private != private ||
793 rpci->ops != ops ||
794 rpci->flags != flags) {
795 dput (dentry);
796 dentry = ERR_PTR(-EBUSY);
797 }
798 rpci->nkern_readwriters++;
799 goto out;
800 }
801 inode = rpc_get_inode(dir->i_sb, S_IFIFO | S_IRUSR | S_IWUSR);
802 if (!inode)
803 goto err_dput;
804 inode->i_ino = iunique(dir->i_sb, 100);
805 inode->i_fop = &rpc_pipe_fops;
806 d_instantiate(dentry, inode);
807 rpci = RPC_I(inode);
808 rpci->private = private;
809 rpci->flags = flags;
810 rpci->ops = ops;
811 rpci->nkern_readwriters = 1;
812 fsnotify_create(dir, dentry);
813 dget(dentry);
814 out:
815 mutex_unlock(&dir->i_mutex);
816 return dentry;
817 err_dput:
818 dput(dentry);
819 dentry = ERR_PTR(-ENOMEM);
820 printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
821 __FILE__, __func__, parent->d_name.name, name,
822 -ENOMEM);
823 goto out;
824 }
825 EXPORT_SYMBOL_GPL(rpc_mkpipe);
826
827 /**
828 * rpc_unlink - remove a pipe
829 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
830 *
831 * After this call, lookups will no longer find the pipe, and any
832 * attempts to read or write using preexisting opens of the pipe will
833 * return -EPIPE.
834 */
835 int
836 rpc_unlink(struct dentry *dentry)
837 {
838 struct dentry *parent;
839 struct inode *dir;
840 int error = 0;
841
842 parent = dget_parent(dentry);
843 dir = parent->d_inode;
844 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
845 if (--RPC_I(dentry->d_inode)->nkern_readwriters == 0) {
846 rpc_close_pipes(dentry->d_inode);
847 error = simple_unlink(dir, dentry);
848 if (!error)
849 d_delete(dentry);
850 }
851 dput(dentry);
852 mutex_unlock(&dir->i_mutex);
853 dput(parent);
854 return error;
855 }
856 EXPORT_SYMBOL_GPL(rpc_unlink);
857
858 /*
859 * populate the filesystem
860 */
861 static struct super_operations s_ops = {
862 .alloc_inode = rpc_alloc_inode,
863 .destroy_inode = rpc_destroy_inode,
864 .statfs = simple_statfs,
865 };
866
867 #define RPCAUTH_GSSMAGIC 0x67596969
868
869 static int
870 rpc_fill_super(struct super_block *sb, void *data, int silent)
871 {
872 struct inode *inode;
873 struct dentry *root;
874
875 sb->s_blocksize = PAGE_CACHE_SIZE;
876 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
877 sb->s_magic = RPCAUTH_GSSMAGIC;
878 sb->s_op = &s_ops;
879 sb->s_time_gran = 1;
880
881 inode = rpc_get_inode(sb, S_IFDIR | 0755);
882 if (!inode)
883 return -ENOMEM;
884 root = d_alloc_root(inode);
885 if (!root) {
886 iput(inode);
887 return -ENOMEM;
888 }
889 if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
890 goto out;
891 sb->s_root = root;
892 return 0;
893 out:
894 d_genocide(root);
895 dput(root);
896 return -ENOMEM;
897 }
898
899 static int
900 rpc_get_sb(struct file_system_type *fs_type,
901 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
902 {
903 return get_sb_single(fs_type, flags, data, rpc_fill_super, mnt);
904 }
905
906 static struct file_system_type rpc_pipe_fs_type = {
907 .owner = THIS_MODULE,
908 .name = "rpc_pipefs",
909 .get_sb = rpc_get_sb,
910 .kill_sb = kill_litter_super,
911 };
912
913 static void
914 init_once(void *foo)
915 {
916 struct rpc_inode *rpci = (struct rpc_inode *) foo;
917
918 inode_init_once(&rpci->vfs_inode);
919 rpci->private = NULL;
920 rpci->nreaders = 0;
921 rpci->nwriters = 0;
922 INIT_LIST_HEAD(&rpci->in_upcall);
923 INIT_LIST_HEAD(&rpci->in_downcall);
924 INIT_LIST_HEAD(&rpci->pipe);
925 rpci->pipelen = 0;
926 init_waitqueue_head(&rpci->waitq);
927 INIT_DELAYED_WORK(&rpci->queue_timeout,
928 rpc_timeout_upcall_queue);
929 rpci->ops = NULL;
930 }
931
932 int register_rpc_pipefs(void)
933 {
934 int err;
935
936 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
937 sizeof(struct rpc_inode),
938 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
939 SLAB_MEM_SPREAD),
940 init_once);
941 if (!rpc_inode_cachep)
942 return -ENOMEM;
943 err = register_filesystem(&rpc_pipe_fs_type);
944 if (err) {
945 kmem_cache_destroy(rpc_inode_cachep);
946 return err;
947 }
948
949 return 0;
950 }
951
952 void unregister_rpc_pipefs(void)
953 {
954 kmem_cache_destroy(rpc_inode_cachep);
955 unregister_filesystem(&rpc_pipe_fs_type);
956 }
Linux with added FPC-III support