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